@skaile/workspaces 0.53.0 → 1.0.0

package/dist/{chunk-QLLFCQU5.js → chunk-WSQ5J7CE.js}

@@ -1,6 +1,4 @@
-import { renderGoogleDriveConfig, renderOneDriveConfig, renderWebDAVConfig } from './chunk-OVRSNIKJ.js';
-import { resolveAuthRef, resolveMountCredentialString, resolveMountCredential } from './chunk-VE2UIJ7Y.js';
-import { PortPool, createFsWatcher, RcloneProcessManager, ensureDirMode } from './chunk-RAIRWFAN.js';
+import { resolveAuthRef } from './chunk-EXNTTJGP.js';
 import { pluginRegistry } from './chunk-6E6PKKAD.js';
 import { computeFlowStateFromSnapshots } from './chunk-SKADPHAM.js';
 import { renderStimulusPrompt } from './chunk-DEYYRFQU.js';
@@ -8,15 +6,16 @@ import { computeStimulus } from './chunk-IFGTRL2I.js';
 import { portableSpawn } from './chunk-3KPNDTMR.js';
 import { createLogger } from './chunk-JB35MVBN.js';
 import { existsSync, mkdirSync, renameSync, writeFileSync, readFileSync, cpSync, statSync, createReadStream, readdirSync, openSync, writeSync, closeSync, chmodSync } from 'fs';
-import path2, { join, dirname, resolve, sep } from 'path';
+import { join, dirname, resolve, sep, relative } from 'path';
 import * as zNS from 'zod';
-import { execFile, execSync, spawn } from 'child_process';
+import { execSync } from 'child_process';
 import { createServer } from 'http';
 import mime from 'mime';
-import { promisify } from 'util';
-import { stat, readdir, writeFile, chmod, rm, mkdir, readFile } from 'fs/promises';
+import { stat, readdir, mkdir, chmod } from 'fs/promises';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
+import { createConnection } from 'net';
+import chokidar from 'chokidar';
 
 // connectors/src/connector-base.ts
 var AbstractConnector = class {
@@ -2110,198 +2109,54 @@ function createConnector5() {
 }
 
 // factory-assets/connectors/googledrive/driver.ts
-var DEFAULT_CACHE_BASE = "/var/cache/skaile";
-function cacheBase() {
-  return process.env.SKAILE_RCLONE_CACHE_BASE ?? DEFAULT_CACHE_BASE;
-}
-var ALLOWED_SCOPES = /* @__PURE__ */ new Set([
-  "drive",
-  "drive.readonly",
-  "drive.file",
-  "drive.appfolder",
-  "drive.metadata.readonly"
-]);
+var CLOUD_FLEET_REQUIRED = "Google Drive cloud connectors require host fleet-managed mounts. Add this connector id to SKAILE_FLEET_MANAGED_MOUNTS and bind the host-managed mount into the workspace container.";
 var GoogleDriveConnector = class extends AbstractConnector {
   name = "googledrive";
-  rclone = new RcloneProcessManager();
   filesystem = {
-    deferMount: true,
-    sync: (handle, options) => {
-      return this._sync(handle, options);
-    }
+    sync: (_handle, options) => syncFleetManaged(options)
   };
   async connect(declaration, ctx) {
     const targetDir = ctx.mountTarget;
     if (!targetDir) {
       throw new Error("GoogleDriveConnector requires ctx.mountTarget to be set by the manager");
     }
-    const secrets = ctx.secrets;
-    const tokenMediator = ctx.tokenMediator;
-    const opts = declaration.options;
-    this.log.info("mount called", {
-      optionKeys: opts ? Object.keys(opts) : []
-    });
-    if (isFleetManaged(declaration.id)) {
-      this.log.info("mount handled by host fleet \u2014 skipping in-container rclone spawn", {
-        connectorId: declaration.id,
-        targetDir
-      });
-      await ensureFleetMounted(targetDir, this.log);
-      const fleetState = {
-        rcloneHandle: null,
-        fleetManaged: true
-      };
-      return this.makeHandle(declaration, fleetState, targetDir);
-    }
-    const scopeRaw = opts?.scope !== void 0 ? String(opts.scope) : "drive";
-    if (!ALLOWED_SCOPES.has(scopeRaw)) {
-      throw new Error(
-        `Google Drive connector: invalid scope "${scopeRaw}" (allowed: ${[...ALLOWED_SCOPES].join(", ")})`
-      );
+    if (!isFleetManaged(declaration.id)) {
+      throw new Error(CLOUD_FLEET_REQUIRED);
     }
-    const scope = scopeRaw;
-    const auth = parseAuthBlob(
-      await resolveMountCredentialString(declaration, secrets, tokenMediator),
-      this.log
-    );
-    if (!auth.accessToken && !auth.serviceAccountFile) {
-      throw new Error(
-        "Google Drive connector: no access token or serviceAccountFile resolved. Use 'auth: backend' (platform) or 'auth: env:GDRIVE_TOKEN' (standalone)."
-      );
-    }
-    const rootFolderId = opts?.rootFolderId !== void 0 ? String(opts.rootFolderId) : null;
-    const teamDrive = opts?.teamDrive !== void 0 ? String(opts.teamDrive) : null;
-    const basePath = String(opts?.basePath ?? "").replace(/^\/+|\/+$/g, "");
-    const remoteName = `skaile-${declaration.id}`;
-    const remotePath = basePath.length > 0 ? `/${basePath}` : "/";
-    const remote = `${remoteName}:${remotePath}`;
-    const base = cacheBase();
-    const cacheDir = `${base}/${declaration.id}`;
-    const vfsCacheMode = declaration.access === "read-only" ? "minimal" : "full";
-    this.log.info("mount params resolved", {
-      scope,
-      remote,
-      cacheDir,
-      vfsCacheMode,
-      hasRefresh: auth.refreshToken !== null,
-      hasServiceAccount: auth.serviceAccountFile !== null,
-      teamDrive
-    });
-    const rcloneConfig = renderGoogleDriveConfig({
-      remoteName,
-      accessToken: auth.accessToken,
-      refreshToken: auth.refreshToken,
-      expiresAtMs: auth.expiresAtMs,
-      clientId: auth.clientId,
-      clientSecret: auth.clientSecret,
-      scope,
-      rootFolderId,
-      teamDrive,
-      serviceAccountFile: auth.serviceAccountFile
-    });
-    await ensureDirMode(base, this.log);
-    await ensureDirMode(cacheDir, this.log);
-    await ensureDirMode(targetDir, this.log);
-    const cacheMaxSize = opts?.cacheMaxSize !== void 0 ? String(opts.cacheMaxSize) : void 0;
-    const cacheMaxAge = opts?.cacheMaxAge !== void 0 ? String(opts.cacheMaxAge) : void 0;
-    const vfsWriteBack = opts?.vfsWriteBack !== void 0 ? String(opts.vfsWriteBack) : void 0;
-    const rcloneHandle = await this.rclone.spawn({
-      mountId: declaration.id,
-      driverName: "googledrive",
-      mountPoint: targetDir,
-      cacheDir,
-      rcloneConfig,
-      remote,
-      vfsCacheMode,
-      ...cacheMaxSize !== void 0 ? { cacheMaxSize } : {},
-      ...cacheMaxAge !== void 0 ? { cacheMaxAge } : {},
-      ...vfsWriteBack !== void 0 ? { vfsWriteBack } : {},
-      log: this.log
+    this.log.info("mount handled by host fleet", {
+      connectorId: declaration.id,
+      targetDir
     });
-    this.log.info("mount ready", { pid: rcloneHandle.pid });
-    const state = {
-      rcloneHandle,
-      // Safe to close over the handle directly: GoogleDrive has no token-refresh
-      // recycle (unlike sharepoint/webdav, which dereference a handleRef so the
-      // hook follows the recycled handle). If a refresh/reconfigure path is ever
-      // added here, switch this to the handleRef indirection or it will query a
-      // stale handle.
-      authoritativeSize: (relPath) => this.rclone.statSize(rcloneHandle, relPath)
-    };
-    return this.makeHandle(declaration, state, targetDir);
-  }
-  async disconnect(handle) {
-    const s = handle.state;
-    if (s.fleetManaged || !s.rcloneHandle) return;
-    await this.rclone.stop(s.rcloneHandle, { graceMs: 3e4 });
+    await ensureFleetMounted(targetDir, this.log);
+    return this.makeHandle(
+      declaration,
+      { fleetManaged: true },
+      targetDir
+    );
   }
-  async _sync(handle, options) {
-    const s = handle.state;
-    if (s.fleetManaged || !s.rcloneHandle) {
-      options?.onSyncStatus?.({
-        phase: "initial_sync_complete",
-        totalFiles: 0,
-        downloadedFiles: 0,
-        stubFiles: 0,
-        message: "fleet-managed mount \u2014 flush handled by host"
-      });
-      return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
-    }
-    await this.rclone.flush(s.rcloneHandle);
-    options?.onSyncStatus?.({
-      phase: "initial_sync_complete",
-      totalFiles: 0,
-      downloadedFiles: 0,
-      stubFiles: 0,
-      message: "rclone flush complete"
-    });
-    return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
+  async disconnect(_handle) {
   }
   async onHibernate(handle) {
-    const s = handle.state;
-    if (s.fleetManaged) return "flushed";
-    await this._sync(handle);
+    await this.filesystem.sync(handle);
     return "flushed";
   }
   async onSessionClose(handle) {
-    const s = handle.state;
-    if (s.fleetManaged) return "flushed";
-    await this._sync(handle);
+    await this.filesystem.sync(handle);
     return "flushed";
   }
 };
 function createConnector6() {
   return new GoogleDriveConnector();
 }
-function parseAuthBlob(raw, log) {
-  const empty = {
-    accessToken: "",
-    refreshToken: null,
-    expiresAtMs: null,
-    clientId: null,
-    clientSecret: null,
-    serviceAccountFile: null
-  };
-  if (!raw) return empty;
-  if (!raw.startsWith("{")) {
-    return { ...empty, accessToken: raw };
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    return {
-      accessToken: parsed.accessToken ?? "",
-      refreshToken: parsed.refreshToken ?? null,
-      expiresAtMs: parsed.expiresAt ?? null,
-      clientId: parsed.clientId ?? null,
-      clientSecret: parsed.clientSecret ?? null,
-      serviceAccountFile: parsed.serviceAccountFile ?? null
-    };
-  } catch (err) {
-    log?.warn("auth blob starts with '{' but is not valid JSON \u2014 treating as raw token", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return { ...empty, accessToken: raw };
-  }
+function syncFleetManaged(options) {
+  options?.onSyncStatus?.({
+    phase: "initial_sync_complete",
+    totalFiles: 0,
+    downloadedFiles: 0,
+    stubFiles: 0,
+    message: "fleet-managed mount \u2014 flush handled by host"
+  });
+  return Promise.resolve({ filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 });
 }
 var LocalConnector = class extends AbstractConnector {
   name = "local";
@@ -2381,8 +2236,8 @@ var MattermostConnector = class extends AbstractConnector {
   constructor() {
     super();
     this.tools = {
-      read: (handle, path3) => this._read(handle, path3),
-      write: (handle, path3, content) => this._write(handle, path3, content),
+      read: (handle, path) => this._read(handle, path),
+      write: (handle, path, content) => this._write(handle, path, content),
       describeOperations: (handle) => this._describeOperations(handle),
       executeOp: (handle, operation, args) => this._executeOp(handle, operation, args),
       describeSkill: (handle, declaration) => this._describeSkill(handle, declaration)
@@ -2454,23 +2309,23 @@ var MattermostConnector = class extends AbstractConnector {
     handle.status = "disconnected";
   }
   // ── Tool face methods (private, wired in constructor) ─────────────────────
-  async _read(handle, path3) {
+  async _read(handle, path) {
     const state = handle.state;
     try {
-      const post = await this._apiGet(state.url, state.token, `/api/v4/posts/${path3}`);
+      const post = await this._apiGet(state.url, state.token, `/api/v4/posts/${path}`);
       this._assertChannelAccess(String(post.channel_id ?? ""), state.channelFilter);
       return { data: JSON.stringify(post, null, 2), contentType: "application/json" };
     } catch {
       return null;
     }
   }
-  async _write(handle, path3, content) {
+  async _write(handle, path, content) {
     if (handle.access === "read-only")
       throw new Error("MattermostConnector: write denied \u2014 read-only");
     const state = handle.state;
     const message = typeof content === "string" ? content : String(content.data ?? "");
-    await this._apiPut(state.url, state.token, `/api/v4/posts/${path3}`, { id: path3, message });
-    this.emitChange?.({ path: path3, action: "edit", source: "operation" });
+    await this._apiPut(state.url, state.token, `/api/v4/posts/${path}`, { id: path, message });
+    this.emitChange?.({ path, action: "edit", source: "operation" });
   }
   _describeSkill(handle, declaration) {
     const state = handle.state;
@@ -2728,31 +2583,31 @@ var MattermostConnector = class extends AbstractConnector {
       return typeof id === "string" && filter.has(id);
     });
   }
-  async _apiGet(baseUrl, token, path3) {
-    const res = await fetch(baseUrl + path3, { headers: { Authorization: `Bearer ${token}` } });
+  async _apiGet(baseUrl, token, path) {
+    const res = await fetch(baseUrl + path, { headers: { Authorization: `Bearer ${token}` } });
     if (!res.ok) {
       const body = await res.text();
-      this.log.warn("REST error", { method: "GET", endpoint: path3, status: res.status });
-      throw new Error(`Mattermost GET ${path3}: ${res.status} ${body}`);
+      this.log.warn("REST error", { method: "GET", endpoint: path, status: res.status });
+      throw new Error(`Mattermost GET ${path}: ${res.status} ${body}`);
     }
     return res.json();
   }
-  async _apiPost(baseUrl, token, path3, body) {
-    const res = await fetch(baseUrl + path3, {
+  async _apiPost(baseUrl, token, path, body) {
+    const res = await fetch(baseUrl + path, {
       method: "POST",
       headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
       body: JSON.stringify(body)
     });
-    if (!res.ok) throw new Error(`Mattermost POST ${path3}: ${res.status} ${await res.text()}`);
+    if (!res.ok) throw new Error(`Mattermost POST ${path}: ${res.status} ${await res.text()}`);
     return res.json();
   }
-  async _apiPut(baseUrl, token, path3, body) {
-    const res = await fetch(baseUrl + path3, {
+  async _apiPut(baseUrl, token, path, body) {
+    const res = await fetch(baseUrl + path, {
       method: "PUT",
       headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
       body: JSON.stringify(body)
     });
-    if (!res.ok) throw new Error(`Mattermost PUT ${path3}: ${res.status} ${await res.text()}`);
+    if (!res.ok) throw new Error(`Mattermost PUT ${path}: ${res.status} ${await res.text()}`);
     return res.json();
   }
 };
@@ -2767,10 +2622,10 @@ var MemoryConnector = class extends AbstractConnector {
   constructor() {
     super();
     this.tools = {
-      read: (handle, path3) => this._read(handle, path3),
-      write: (handle, path3, content) => this._write(handle, path3, content),
-      delete: (handle, path3) => this._delete(handle, path3),
-      list: (handle, path3, options) => this._list(handle, path3, options),
+      read: (handle, path) => this._read(handle, path),
+      write: (handle, path, content) => this._write(handle, path, content),
+      delete: (handle, path) => this._delete(handle, path),
+      list: (handle, path, options) => this._list(handle, path, options),
       search: (handle, query, options) => this._search(handle, query, options),
       describeOperations: (handle) => this._describeOperations(handle),
       executeOp: (handle, operation, args) => this._executeOp(handle, operation, args)
@@ -2789,26 +2644,26 @@ var MemoryConnector = class extends AbstractConnector {
   store(handle) {
     return handle.state.store;
   }
-  async _read(handle, path3) {
-    const value = this.store(handle).get(path3);
+  async _read(handle, path) {
+    const value = this.store(handle).get(path);
     if (value === void 0) return null;
     return { data: value, contentType: "application/json" };
   }
-  async _write(handle, path3, content) {
-    const isNew = !this.store(handle).has(path3);
+  async _write(handle, path, content) {
+    const isNew = !this.store(handle).has(path);
     this.store(handle).set(
-      path3,
+      path,
       typeof content.data === "string" ? content.data : content.data.toString("utf-8")
     );
-    this.emitChange?.({ path: path3, action: isNew ? "create" : "edit", source: "operation" });
+    this.emitChange?.({ path, action: isNew ? "create" : "edit", source: "operation" });
   }
-  async _delete(handle, path3) {
-    const deleted = this.store(handle).delete(path3);
-    if (deleted) this.emitChange?.({ path: path3, action: "delete", source: "operation" });
+  async _delete(handle, path) {
+    const deleted = this.store(handle).delete(path);
+    if (deleted) this.emitChange?.({ path, action: "delete", source: "operation" });
     return deleted;
   }
-  async _list(handle, path3, options) {
-    const prefix = path3 ?? "";
+  async _list(handle, path, options) {
+    const prefix = path ?? "";
     const entries = [];
     for (const key of this.store(handle).keys()) {
       if (prefix && !key.startsWith(prefix)) continue;
@@ -2921,8 +2776,8 @@ var MinIOConnector = class extends AbstractConnector {
   constructor() {
     super();
     this.tools = {
-      list: (handle, path3) => this._list(handle, path3),
-      read: (handle, path3) => this._read(handle, path3),
+      list: (handle, path) => this._list(handle, path),
+      read: (handle, path) => this._read(handle, path),
       describeOperations: (handle) => this._describeOperations(handle),
       executeOp: (handle, operation, args) => this._executeOp(handle, operation, args),
       describeSkill: (handle, declaration) => this._describeSkill(handle, declaration)
@@ -3100,10 +2955,10 @@ var MinIOConnector = class extends AbstractConnector {
     }
     return ops;
   }
-  async _list(handle, path3, recursive = false) {
+  async _list(handle, path, recursive = false) {
     const { client, bucket } = handle.state;
     const entries = [];
-    const stream = client.listObjects(bucket, path3 ?? "", recursive);
+    const stream = client.listObjects(bucket, path ?? "", recursive);
     return new Promise((resolve5, reject) => {
       stream.on("data", (obj) => {
         entries.push({
@@ -3118,10 +2973,10 @@ var MinIOConnector = class extends AbstractConnector {
       stream.on("error", reject);
     });
   }
-  async _read(handle, path3) {
+  async _read(handle, path) {
     const { client, bucket } = handle.state;
     const chunks = [];
-    const stream = await client.getObject(bucket, path3);
+    const stream = await client.getObject(bucket, path);
     return new Promise((resolve5, reject) => {
       stream.on("data", (chunk) => chunks.push(chunk));
       stream.on("end", () => resolve5({ data: Buffer.concat(chunks).toString() }));
@@ -3179,8 +3034,8 @@ var PostgresConnector = class extends AbstractConnector {
   constructor() {
     super();
     this.tools = {
-      read: (handle, path3) => this._read(handle, path3),
-      list: (handle, path3, options) => this._list(handle, path3, options),
+      read: (handle, path) => this._read(handle, path),
+      list: (handle, path, options) => this._list(handle, path, options),
       search: (handle, query, options) => this._search(handle, query, options),
       describeOperations: (handle) => this._describeOperations(handle),
       executeOp: (handle, operation, args) => this._executeOp(handle, operation, args),
@@ -3268,8 +3123,8 @@ var PostgresConnector = class extends AbstractConnector {
     return handle.state.pool;
   }
   // Base ops map to table/row access via path convention: <table>/<pk>
-  async _read(handle, path3) {
-    const parts = path3.split("/");
+  async _read(handle, path) {
+    const parts = path.split("/");
     if (parts.length === 1) {
       const table2 = parts[0];
       const result2 = await this.pool(handle).query(
@@ -3288,8 +3143,8 @@ var PostgresConnector = class extends AbstractConnector {
     if (result.rows.length === 0) return null;
     return { data: JSON.stringify(result.rows[0], null, 2), contentType: "application/json" };
   }
-  async _list(handle, path3, options) {
-    if (!path3) {
+  async _list(handle, path, options) {
+    if (!path) {
       const result2 = await this.pool(handle).query(
         `SELECT table_name FROM information_schema.tables
          WHERE table_schema = 'public' ORDER BY table_name`
@@ -3301,12 +3156,12 @@ var PostgresConnector = class extends AbstractConnector {
       }));
     }
     const limit = options?.limit ?? 100;
-    const result = await this.pool(handle).query(`SELECT * FROM "${quoteIdent(path3)}" LIMIT $1`, [
+    const result = await this.pool(handle).query(`SELECT * FROM "${quoteIdent(path)}" LIMIT $1`, [
       limit
     ]);
     return result.rows.map((row, i) => ({
       name: String(row.id ?? i),
-      path: `${path3}/${row.id ?? i}`,
+      path: `${path}/${row.id ?? i}`,
       type: "row"
     }));
   }
@@ -3586,216 +3441,54 @@ function createConnector12(sdkOverride) {
 }
 
 // factory-assets/connectors/sharepoint/driver.ts
-var DEFAULT_CACHE_BASE2 = "/var/cache/skaile";
-function cacheBase2() {
-  return process.env.SKAILE_RCLONE_CACHE_BASE ?? DEFAULT_CACHE_BASE2;
-}
+var CLOUD_FLEET_REQUIRED2 = "SharePoint cloud connectors require host fleet-managed mounts. Add this connector id to SKAILE_FLEET_MANAGED_MOUNTS and bind the host-managed mount into the workspace container.";
 var SharePointConnector = class extends AbstractConnector {
   name = "sharepoint";
-  rclone = new RcloneProcessManager();
   filesystem = {
-    deferMount: true,
-    sync: (handle, options) => {
-      return this._sync(handle, options);
-    }
+    sync: (_handle, options) => syncFleetManaged2(options)
   };
   async connect(declaration, ctx) {
     const targetDir = ctx.mountTarget;
     if (!targetDir) {
       throw new Error("SharePointConnector requires ctx.mountTarget to be set by the manager");
     }
-    const secrets = ctx.secrets;
-    const tokenMediator = ctx.tokenMediator;
-    const opts = declaration.options;
-    this.log.info("mount called", {
-      optionKeys: opts ? Object.keys(opts) : []
-    });
-    if (isFleetManaged(declaration.id)) {
-      this.log.info("mount handled by host fleet \u2014 skipping in-container rclone spawn", {
-        connectorId: declaration.id,
-        targetDir
-      });
-      await ensureFleetMounted(targetDir, this.log);
-      const fleetState = {
-        handleRef: { current: null },
-        fleetManaged: true
-      };
-      return this.makeHandle(declaration, fleetState, targetDir);
-    }
-    const driveId = String(opts?.driveId ?? "");
-    if (!driveId) {
-      throw new Error("SharePoint connector requires options.driveId");
+    if (!isFleetManaged(declaration.id)) {
+      throw new Error(CLOUD_FLEET_REQUIRED2);
     }
-    const folderPath = String(opts?.folderPath ?? "").trim();
-    if (!folderPath) {
-      throw new Error(
-        "SharePoint connector requires options.folderPath (rclone backend needs a path string, not just folderId)"
-      );
-    }
-    const basePath = String(opts?.basePath ?? "").replace(/^\/+|\/+$/g, "");
-    const cred = await resolveMountCredential(declaration, secrets, tokenMediator, "initial");
-    const auth = parseAuthBlob2(cred.token, this.log);
-    if (!auth.accessToken) {
-      throw new Error(
-        "SharePoint connector: no access token resolved. Use 'auth: backend' (platform) or 'auth: env:SHAREPOINT_TOKEN' (standalone)."
-      );
-    }
-    const remoteName = `skaile-${declaration.id}`;
-    const remotePath = buildRemotePath(folderPath, basePath);
-    const remote = `${remoteName}:${remotePath}`;
-    const base = cacheBase2();
-    const cacheDir = `${base}/${declaration.id}`;
-    const vfsCacheMode = declaration.access === "read-only" ? "minimal" : "full";
-    this.log.info("mount params resolved", {
-      driveId,
-      remote,
-      cacheDir,
-      vfsCacheMode,
-      hasRefresh: auth.refreshToken !== null
-    });
-    const renderConfig = (rawToken) => {
-      const a = parseAuthBlob2(rawToken, this.log);
-      return renderOneDriveConfig({
-        remoteName,
-        accessToken: a.accessToken,
-        refreshToken: a.refreshToken,
-        expiresAtMs: a.expiresAtMs,
-        tenantId: a.tenantId,
-        clientId: a.clientId,
-        clientSecret: a.clientSecret,
-        driveId
-      });
-    };
-    const handleRef = { current: null };
-    const refresh = declaration.auth === "backend" && tokenMediator ? createRcloneTokenRefresh({
+    this.log.info("mount handled by host fleet", {
       connectorId: declaration.id,
-      tokenMediator,
-      renderConfig,
-      rclone: this.rclone,
-      handleRef,
-      log: (line) => this.log.info(line)
-    }) : void 0;
-    const rcloneConfig = renderConfig(cred.token ?? "");
-    await ensureDirMode(base, this.log);
-    await ensureDirMode(cacheDir, this.log);
-    await ensureDirMode(targetDir, this.log);
-    const cacheMaxSize = opts?.cacheMaxSize !== void 0 ? String(opts.cacheMaxSize) : void 0;
-    const cacheMaxAge = opts?.cacheMaxAge !== void 0 ? String(opts.cacheMaxAge) : void 0;
-    const vfsWriteBack = opts?.vfsWriteBack !== void 0 ? String(opts.vfsWriteBack) : void 0;
-    const ignoreSizeCheck = opts?.ignoreSizeCheck === true;
-    if (ignoreSizeCheck) {
-      this.log.warn(
-        "ignoreSizeCheck enabled \u2014 rclone post-transfer size/checksum verification disabled for this mount",
-        { connectorId: declaration.id }
-      );
-    }
-    const rcloneHandle = await this.rclone.spawn({
-      mountId: declaration.id,
-      driverName: "sharepoint",
-      mountPoint: targetDir,
-      cacheDir,
-      rcloneConfig,
-      remote,
-      vfsCacheMode,
-      ...cacheMaxSize !== void 0 ? { cacheMaxSize } : {},
-      ...cacheMaxAge !== void 0 ? { cacheMaxAge } : {},
-      ...vfsWriteBack !== void 0 ? { vfsWriteBack } : {},
-      ...ignoreSizeCheck ? { ignoreSizeCheck: true } : {},
-      ...refresh ? { onAuthError: () => refresh.onAuthError() } : {},
-      log: this.log
+      targetDir
     });
-    this.log.info("mount ready", { pid: rcloneHandle.pid });
-    handleRef.current = rcloneHandle;
-    refresh?.schedule(cred.expiresAt);
-    const state = {
-      handleRef,
-      refresh,
-      authoritativeSize: (relPath) => {
-        const h = handleRef.current;
-        return h ? this.rclone.statSize(h, relPath) : Promise.resolve(null);
-      }
-    };
-    return this.makeHandle(declaration, state, targetDir);
-  }
-  async disconnect(handle) {
-    const s = handle.state;
-    s.refresh?.cancel();
-    if (s.fleetManaged || !s.handleRef.current) return;
-    await this.rclone.stop(s.handleRef.current, { graceMs: 3e4 });
+    await ensureFleetMounted(targetDir, this.log);
+    return this.makeHandle(
+      declaration,
+      { fleetManaged: true },
+      targetDir
+    );
   }
-  async _sync(handle, options) {
-    const s = handle.state;
-    if (s.fleetManaged || !s.handleRef.current) {
-      options?.onSyncStatus?.({
-        phase: "initial_sync_complete",
-        totalFiles: 0,
-        downloadedFiles: 0,
-        stubFiles: 0,
-        message: "fleet-managed mount \u2014 flush handled by host"
-      });
-      return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
-    }
-    await this.rclone.flush(s.handleRef.current);
-    options?.onSyncStatus?.({
-      phase: "initial_sync_complete",
-      totalFiles: 0,
-      downloadedFiles: 0,
-      stubFiles: 0,
-      message: "rclone flush complete"
-    });
-    return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
+  async disconnect(_handle) {
   }
   async onHibernate(handle) {
-    const s = handle.state;
-    if (s.fleetManaged) return "flushed";
-    await this._sync(handle);
+    await this.filesystem.sync(handle);
     return "flushed";
   }
   async onSessionClose(handle) {
-    const s = handle.state;
-    if (s.fleetManaged) return "flushed";
-    await this._sync(handle);
+    await this.filesystem.sync(handle);
     return "flushed";
   }
 };
 function createConnector13() {
   return new SharePointConnector();
 }
-function parseAuthBlob2(raw, log) {
-  const empty = {
-    accessToken: "",
-    refreshToken: null,
-    expiresAtMs: null,
-    tenantId: null,
-    clientId: null,
-    clientSecret: null
-  };
-  if (!raw) return empty;
-  if (!raw.startsWith("{")) {
-    return { ...empty, accessToken: raw };
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    return {
-      accessToken: parsed.accessToken ?? "",
-      refreshToken: parsed.refreshToken ?? null,
-      expiresAtMs: parsed.expiresAt ?? null,
-      tenantId: parsed.tenantId ?? null,
-      clientId: parsed.clientId ?? null,
-      clientSecret: parsed.clientSecret ?? null
-    };
-  } catch (err) {
-    log?.warn("auth blob starts with '{' but is not valid JSON \u2014 treating as raw token", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return { ...empty, accessToken: raw };
-  }
-}
-function buildRemotePath(folderPath, basePath) {
-  const folder = folderPath.replace(/^\/+|\/+$/g, "");
-  const base = basePath.replace(/^\/+|\/+$/g, "");
-  const joined = [folder, base].filter((p) => p.length > 0).join("/");
-  return joined.length > 0 ? `/${joined}` : "/";
+function syncFleetManaged2(options) {
+  options?.onSyncStatus?.({
+    phase: "initial_sync_complete",
+    totalFiles: 0,
+    downloadedFiles: 0,
+    stubFiles: 0,
+    message: "fleet-managed mount \u2014 flush handled by host"
+  });
+  return Promise.resolve({ filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 });
 }
 function quoteIdent2(ident) {
   return ident.replace(/"/g, '""');
@@ -3806,8 +3499,8 @@ var SQLiteConnector = class extends AbstractConnector {
   constructor() {
     super();
     this.tools = {
-      read: (handle, path3) => this._read(handle, path3),
-      list: (handle, path3, options) => this._list(handle, path3, options),
+      read: (handle, path) => this._read(handle, path),
+      list: (handle, path, options) => this._list(handle, path, options),
       search: (handle, query, options) => this._search(handle, query, options),
       describeOperations: (handle) => this._describeOperations(handle),
       executeOp: (handle, operation, args) => this._executeOp(handle, operation, args)
@@ -3891,8 +3584,8 @@ var SQLiteConnector = class extends AbstractConnector {
     const changes = db.getRowsModified();
     return changes;
   }
-  async _read(handle, path3) {
-    const parts = path3.split("/");
+  async _read(handle, path) {
+    const parts = path.split("/");
     if (parts.length === 1) {
       const table2 = parts[0];
       const info = this.queryRows(this.db(handle), `PRAGMA table_info("${quoteIdent2(table2)}")`);
@@ -3908,8 +3601,8 @@ var SQLiteConnector = class extends AbstractConnector {
     if (rows.length === 0) return null;
     return { data: JSON.stringify(rows[0], null, 2), contentType: "application/json" };
   }
-  async _list(handle, path3, options) {
-    if (!path3) {
+  async _list(handle, path, options) {
+    if (!path) {
       const tables = this.queryRows(
         this.db(handle),
         "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
@@ -3923,12 +3616,12 @@ var SQLiteConnector = class extends AbstractConnector {
     const limit = options?.limit ?? 100;
     const rows = this.queryRows(
       this.db(handle),
-      `SELECT rowid, * FROM "${quoteIdent2(path3)}" LIMIT ?`,
+      `SELECT rowid, * FROM "${quoteIdent2(path)}" LIMIT ?`,
       [limit]
     );
     return rows.map((row) => ({
       name: String(row.rowid ?? row.id ?? "?"),
-      path: `${path3}/${row.rowid ?? row.id ?? "?"}`,
+      path: `${path}/${row.rowid ?? row.id ?? "?"}`,
       type: "row"
     }));
   }
@@ -4538,215 +4231,52 @@ async function spawnNgrokTunnel(port) {
 function createConnector16() {
   return new TunnelConnector();
 }
-var DEFAULT_CACHE_BASE3 = "/var/cache/skaile";
-function cacheBase3() {
-  return process.env.SKAILE_RCLONE_CACHE_BASE ?? DEFAULT_CACHE_BASE3;
-}
-var ALLOWED_VENDORS = /* @__PURE__ */ new Set([
-  "nextcloud",
-  "owncloud",
-  "sharepoint",
-  "fastmail",
-  "other"
-]);
-var execFileP = promisify(execFile);
+
+// factory-assets/connectors/webdav/driver.ts
+var CLOUD_FLEET_REQUIRED3 = "WebDAV cloud connectors require host fleet-managed mounts. Add this connector id to SKAILE_FLEET_MANAGED_MOUNTS and bind the host-managed mount into the workspace container.";
 var WebDAVConnector = class extends AbstractConnector {
-  // Injectable so tests can stub the `rclone obscure` shell-out; production
-  // wires the real binary via createConnector().
-  constructor(obscure = obscurePassword) {
-    super();
-    this.obscure = obscure;
-  }
-  obscure;
   name = "webdav";
-  rclone = new RcloneProcessManager();
   filesystem = {
-    deferMount: true,
-    sync: (handle, options) => {
-      return this._sync(handle, options);
-    }
+    sync: (_handle, options) => syncFleetManaged3(options)
   };
   async connect(declaration, ctx) {
     const targetDir = ctx.mountTarget;
     if (!targetDir) {
       throw new Error("WebDAVConnector requires ctx.mountTarget to be set by the manager");
     }
-    const secrets = ctx.secrets;
-    const tokenMediator = ctx.tokenMediator;
-    const opts = declaration.options;
-    this.log.info("mount called", {
-      optionKeys: opts ? Object.keys(opts) : [],
-      hasAuth: declaration.auth !== void 0
-    });
-    if (isFleetManaged(declaration.id)) {
-      this.log.info("mount handled by host fleet \u2014 skipping in-container rclone spawn", {
-        connectorId: declaration.id,
-        targetDir
-      });
-      await ensureFleetMounted(targetDir, this.log);
-      const fleetState = {
-        handleRef: { current: null },
-        fleetManaged: true
-      };
-      return this.makeHandle(declaration, fleetState, targetDir);
-    }
-    const url = String(declaration.mount?.source ?? "").trim();
-    if (!url) {
-      throw new Error("WebDAV connector requires declaration.mount.source (server URL)");
-    }
-    const vendorRaw = opts?.vendor !== void 0 ? String(opts.vendor) : "other";
-    if (!ALLOWED_VENDORS.has(vendorRaw)) {
-      throw new Error(
-        `WebDAV connector: invalid vendor "${vendorRaw}" (allowed: ${[...ALLOWED_VENDORS].join(", ")})`
-      );
+    if (!isFleetManaged(declaration.id)) {
+      throw new Error(CLOUD_FLEET_REQUIRED3);
     }
-    const vendor = vendorRaw;
-    const basePath = String(opts?.basePath ?? "").replace(/^\/+|\/+$/g, "");
-    const remotePath = basePath.length > 0 ? `/${basePath}` : "/";
-    const cred = await resolveMountCredential(declaration, secrets, tokenMediator, "initial");
-    const auth = parseAuth(cred.token);
-    const remoteName = `skaile-${declaration.id}`;
-    const remote = `${remoteName}:${remotePath}`;
-    const base = cacheBase3();
-    const cacheDir = `${base}/${declaration.id}`;
-    const vfsCacheMode = declaration.access === "read-only" ? "minimal" : "full";
-    this.log.info("mount params resolved", {
-      url,
-      vendor,
-      remote,
-      cacheDir,
-      vfsCacheMode,
-      authKind: auth.bearerToken ? "bearer" : auth.username ? "basic" : "anonymous"
-    });
-    const renderConfig = async (rawToken) => {
-      const a = parseAuth(rawToken);
-      const obscured = a.password ? await this.obscure(a.password) : null;
-      return renderWebDAVConfig({
-        remoteName,
-        url,
-        vendor,
-        username: a.username,
-        obscuredPassword: obscured,
-        bearerToken: a.bearerToken
-      });
-    };
-    const handleRef = { current: null };
-    const refresh = declaration.auth === "backend" && tokenMediator ? createRcloneTokenRefresh({
+    this.log.info("mount handled by host fleet", {
       connectorId: declaration.id,
-      tokenMediator,
-      renderConfig,
-      rclone: this.rclone,
-      handleRef,
-      log: (line) => this.log.info(line)
-    }) : void 0;
-    const rcloneConfig = await renderConfig(cred.token ?? "");
-    await ensureDirMode(base, this.log);
-    await ensureDirMode(cacheDir, this.log);
-    await ensureDirMode(targetDir, this.log);
-    const cacheMaxSize = opts?.cacheMaxSize !== void 0 ? String(opts.cacheMaxSize) : void 0;
-    const cacheMaxAge = opts?.cacheMaxAge !== void 0 ? String(opts.cacheMaxAge) : void 0;
-    const vfsWriteBack = opts?.vfsWriteBack !== void 0 ? String(opts.vfsWriteBack) : void 0;
-    const rcloneHandle = await this.rclone.spawn({
-      mountId: declaration.id,
-      driverName: "webdav",
-      mountPoint: targetDir,
-      cacheDir,
-      rcloneConfig,
-      remote,
-      vfsCacheMode,
-      ...cacheMaxSize !== void 0 ? { cacheMaxSize } : {},
-      ...cacheMaxAge !== void 0 ? { cacheMaxAge } : {},
-      ...vfsWriteBack !== void 0 ? { vfsWriteBack } : {},
-      ...refresh ? { onAuthError: () => refresh.onAuthError() } : {},
-      log: this.log
+      targetDir
     });
-    this.log.info("mount ready", { pid: rcloneHandle.pid });
-    handleRef.current = rcloneHandle;
-    refresh?.schedule(cred.expiresAt);
-    const state = {
-      handleRef,
-      refresh,
-      authoritativeSize: (relPath) => {
-        const h = handleRef.current;
-        return h ? this.rclone.statSize(h, relPath) : Promise.resolve(null);
-      }
-    };
-    return this.makeHandle(declaration, state, targetDir);
-  }
-  async disconnect(handle) {
-    const s = handle.state;
-    s.refresh?.cancel();
-    if (s.fleetManaged || !s.handleRef.current) return;
-    await this.rclone.stop(s.handleRef.current, { graceMs: 3e4 });
+    await ensureFleetMounted(targetDir, this.log);
+    return this.makeHandle(declaration, { fleetManaged: true }, targetDir);
   }
-  async _sync(handle, options) {
-    const s = handle.state;
-    if (s.fleetManaged || !s.handleRef.current) {
-      options?.onSyncStatus?.({
-        phase: "initial_sync_complete",
-        totalFiles: 0,
-        downloadedFiles: 0,
-        stubFiles: 0,
-        message: "fleet-managed mount \u2014 flush handled by host"
-      });
-      return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
-    }
-    await this.rclone.flush(s.handleRef.current);
-    options?.onSyncStatus?.({
-      phase: "initial_sync_complete",
-      totalFiles: 0,
-      downloadedFiles: 0,
-      stubFiles: 0,
-      message: "rclone flush complete"
-    });
-    return { filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 };
+  async disconnect(_handle) {
   }
   async onHibernate(handle) {
-    const s = handle.state;
-    if (s.fleetManaged) return "flushed";
-    await this._sync(handle);
+    await this.filesystem.sync(handle);
     return "flushed";
   }
   async onSessionClose(handle) {
-    const s = handle.state;
-    if (s.fleetManaged) return "flushed";
-    await this._sync(handle);
+    await this.filesystem.sync(handle);
     return "flushed";
   }
 };
 function createConnector17() {
   return new WebDAVConnector();
 }
-function parseAuth(raw) {
-  const empty = {
-    username: null,
-    password: null,
-    bearerToken: null
-  };
-  if (!raw) return empty;
-  const colonIdx = raw.indexOf(":");
-  if (colonIdx === -1) {
-    return { ...empty, bearerToken: raw };
-  }
-  const username = raw.slice(0, colonIdx);
-  const password = raw.slice(colonIdx + 1);
-  return { username, password, bearerToken: null };
-}
-async function obscurePassword(plain) {
-  try {
-    const { stdout } = await execFileP("rclone", ["obscure", plain]);
-    return stdout.trim();
-  } catch (err) {
-    const code = err?.code;
-    if (code === "ENOENT") {
-      throw new Error(
-        "WebDAV connector: rclone binary not found on PATH (install rclone to use the webdav connector)"
-      );
-    }
-    throw new Error(
-      `WebDAV connector: 'rclone obscure' failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
+function syncFleetManaged3(options) {
+  options?.onSyncStatus?.({
+    phase: "initial_sync_complete",
+    totalFiles: 0,
+    downloadedFiles: 0,
+    stubFiles: 0,
+    message: "fleet-managed mount \u2014 flush handled by host"
+  });
+  return Promise.resolve({ filesWritten: 0, filesDeleted: 0, bytesTransferred: 0 });
 }
 var XStateConnector = class extends AbstractConnector {
   name = "xstate";
@@ -4754,8 +4284,8 @@ var XStateConnector = class extends AbstractConnector {
   constructor() {
     super();
     this.tools = {
-      read: (handle, path3) => this._read(handle, path3),
-      list: (handle, path3, options) => this._list(handle, path3, options),
+      read: (handle, path) => this._read(handle, path),
+      list: (handle, path, options) => this._list(handle, path, options),
       search: (handle, query) => this._search(handle, query),
       describeOperations: (handle) => this._describeOperations(handle),
       executeOp: (handle, operation, args) => this._executeOp(handle, operation, args)
@@ -4857,15 +4387,15 @@ var XStateConnector = class extends AbstractConnector {
     this.s(handle).onChange = cb;
   }
   // ── Tool face methods (private, wired in constructor) ─────────────────────
-  async _read(handle, path3) {
+  async _read(handle, path) {
     const snapshot = this.s(handle).actor.getSnapshot();
-    if (path3 === "" || path3 === "state") {
+    if (path === "" || path === "state") {
       return { data: JSON.stringify(snapshot.value), contentType: "application/json" };
     }
-    if (path3 === "context") {
+    if (path === "context") {
       return { data: JSON.stringify(snapshot.context, null, 2), contentType: "application/json" };
     }
-    const value = snapshot.context?.[path3];
+    const value = snapshot.context?.[path];
     if (value === void 0) return null;
     return { data: JSON.stringify(value), contentType: "application/json" };
   }
@@ -5059,10 +4589,10 @@ var XStateStoreConnector = class extends AbstractConnector {
   constructor() {
     super();
     this.tools = {
-      read: (handle, path3) => this._read(handle, path3),
-      write: (handle, path3, content) => this._write(handle, path3, content),
-      delete: (handle, path3) => this._delete(handle, path3),
-      list: (handle, path3, options) => this._list(handle, path3, options),
+      read: (handle, path) => this._read(handle, path),
+      write: (handle, path, content) => this._write(handle, path, content),
+      delete: (handle, path) => this._delete(handle, path),
+      list: (handle, path, options) => this._list(handle, path, options),
       search: (handle, query, options) => this._search(handle, query, options),
       describeOperations: (handle) => this._describeOperations(handle),
       executeOp: (handle, operation, args) => this._executeOp(handle, operation, args)
@@ -5116,17 +4646,17 @@ var XStateStoreConnector = class extends AbstractConnector {
     handle.state.onChange = cb;
   }
   // ── Tool face methods (private, wired in constructor) ─────────────────────
-  async _read(handle, path3) {
+  async _read(handle, path) {
     const ctx = this.context(handle);
-    if (path3 === "*") {
+    if (path === "*") {
       if (Object.keys(ctx).length === 0) return null;
       return { data: JSON.stringify(ctx, null, 2), contentType: "application/json" };
     }
-    const value = ctx[path3];
+    const value = ctx[path];
     if (value === void 0) return null;
     return { data: JSON.stringify(value), contentType: "application/json" };
   }
-  async _write(handle, path3, content) {
+  async _write(handle, path, content) {
     const data = typeof content.data === "string" ? content.data : content.data.toString("utf-8");
     let value;
     try {
@@ -5134,14 +4664,14 @@ var XStateStoreConnector = class extends AbstractConnector {
     } catch {
       value = data;
     }
-    this.storeState(handle).store.send({ type: "set", key: path3, value });
-    this._recordHistory(handle, "set", { key: path3, value });
+    this.storeState(handle).store.send({ type: "set", key: path, value });
+    this._recordHistory(handle, "set", { key: path, value });
   }
-  async _delete(handle, path3) {
+  async _delete(handle, path) {
     const ctx = this.context(handle);
-    if (!(path3 in ctx)) return false;
-    this.storeState(handle).store.send({ type: "delete", key: path3 });
-    this._recordHistory(handle, "delete", { key: path3 });
+    if (!(path in ctx)) return false;
+    this.storeState(handle).store.send({ type: "delete", key: path });
+    this._recordHistory(handle, "delete", { key: path });
     return true;
   }
   async _list(handle, _path, options) {
@@ -5446,418 +4976,8 @@ var ConnectorStartupError = class extends Error {
   }
 };
 
-// connectors/src/fleet-health-gate.ts
-function verdictToSurface(verdict) {
-  if (verdict === "healthy") return "open";
-  if (verdict === "degraded") return "ro";
-  return "masked";
-}
-var FleetHealthGate = class {
-  constructor(target, barrier, log, opts) {
-    this.target = target;
-    this.barrier = barrier;
-    this.log = log;
-    this.unhealthyThreshold = Math.max(1, opts?.unhealthyThreshold ?? 2);
-    this.healthyThreshold = Math.max(1, opts?.healthyThreshold ?? 2);
-    const initial = opts?.initialSurface ?? "open";
-    this.surface = initial;
-    this.pendingSurface = initial;
-    this.runSurface = initial;
-  }
-  target;
-  barrier;
-  log;
-  unhealthyThreshold;
-  healthyThreshold;
-  /** The barrier surface actually applied to the target right now. */
-  surface;
-  /**
-   * The surface the most recently *enqueued* transition will settle on.
-   * Hysteresis and re-enqueue de-duping are measured against this, not
-   * `surface`, so verdicts arriving while a (slow, async) barrier op is still in
-   * flight are counted toward the post-transition surface, not the stale one.
-   */
-  pendingSurface;
-  /** The surface of the *current* same-verdict run, and its length. */
-  runSurface;
-  runLength = 0;
-  /** Serialises barrier ops so overlapping observe() calls can't race. */
-  transition = Promise.resolve();
-  /** True while any read-only barrier (ro or masked) is established. */
-  get isGated() {
-    return this.surface !== "open";
-  }
-  /** The currently-applied surface (test/observability hook). */
-  get currentSurface() {
-    return this.surface;
-  }
-  /** The mount target this gate guards (recovery-probe lookup). */
-  get mountTarget() {
-    return this.target;
-  }
-  /**
-   * Feed one health verdict. Applies hysteresis, then drives the barrier toward
-   * the target surface on a change. Resolves once the (possibly no-op)
-   * transition is applied. Never throws — a failed barrier op stays gated
-   * (fail-closed).
-   */
-  observe(verdict) {
-    const desired = verdictToSurface(verdict);
-    if (desired === this.runSurface) {
-      this.runLength += 1;
-    } else {
-      this.runSurface = desired;
-      this.runLength = 1;
-    }
-    const threshold = desired === "open" ? this.healthyThreshold : this.unhealthyThreshold;
-    if (desired !== this.pendingSurface && this.runLength >= threshold) {
-      this.pendingSurface = desired;
-      this.runLength = 0;
-      return this.enqueue(() => this.apply(desired));
-    }
-    return this.transition;
-  }
-  /**
-   * Tear the gate down. If any barrier is established (or in flight), removes it
-   * so a leftover read-only surface is not leaked. Call only after the connector
-   * above the target is disconnected (top-down, no leaked mount).
-   */
-  dispose() {
-    if (this.surface === "open" && this.pendingSurface === "open") return this.transition;
-    this.pendingSurface = "open";
-    return this.enqueue(() => this.apply("open"));
-  }
-  enqueue(step) {
-    this.transition = this.transition.then(step, step);
-    return this.transition;
-  }
-  /** Drive the barrier to `desired`, fail-closed to `masked` on any throw. */
-  async apply(desired) {
-    if (this.surface === desired) {
-      this.pendingSurface = desired;
-      return;
-    }
-    try {
-      if (desired === "open") {
-        await this.barrier.remove(this.target, this.log);
-        this.surface = "open";
-        this.log?.info("fleet mount recovered \u2014 gate lifted, writable again", {
-          target: this.target
-        });
-        return;
-      }
-      if (desired === "ro") {
-        if (this.barrier.exposeReadOnly) {
-          await this.barrier.exposeReadOnly(this.target, this.log);
-        } else {
-          await this.barrier.establish(this.target, this.log);
-        }
-        this.surface = "ro";
-        this.log?.warn("fleet mount upload-degraded \u2014 gated read-only (content visible)", {
-          target: this.target
-        });
-        return;
-      }
-      await this.barrier.establish(this.target, this.log);
-      this.surface = "masked";
-      this.log?.warn("fleet mount unhealthy \u2014 gated read-only (masked)", { target: this.target });
-    } catch (err) {
-      const safe = "masked";
-      this.surface = safe;
-      this.pendingSurface = safe;
-      this.log?.error(
-        `fleet read-only gate transition to '${desired}' threw \u2014 biasing to '${safe}' (fail-closed)`,
-        err,
-        { target: this.target }
-      );
-    }
-  }
-};
-function isFleetManaged(connectorId) {
-  const raw = process.env.SKAILE_FLEET_MANAGED_MOUNTS ?? "";
-  if (raw.length === 0) return false;
-  return raw.split(",").map((segment) => segment.trim()).filter((segment) => segment.length > 0).includes(connectorId);
-}
-async function ensureFleetMounted(dir, log, options) {
-  const timeoutMs = options?.timeoutMs ?? 3e3;
-  const pollIntervalMs = options?.pollIntervalMs ?? 100;
-  const deadline = Date.now() + timeoutMs;
-  let lastErr = null;
-  while (Date.now() < deadline) {
-    try {
-      const st = await stat(dir);
-      if (!st.isDirectory()) {
-        throw new Error(`fleet mountpoint ${dir} is not a directory`);
-      }
-      await readdir(dir);
-      log.info("fleet bind mount verified", { dir });
-      return;
-    } catch (err) {
-      lastErr = err;
-      await new Promise((resolve5) => setTimeout(resolve5, pollIntervalMs));
-    }
-  }
-  throw new Error(
-    `fleet mount ${dir} not ready after ${timeoutMs}ms \u2014 check SKAILE_FLEET_MANAGED_MOUNTS env var and host bind: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
-  );
-}
-async function probeFleetHealth(dir) {
-  try {
-    const st = await stat(dir);
-    if (!st.isDirectory()) return "error";
-    await readdir(dir);
-    return "healthy";
-  } catch {
-    return "error";
-  }
-}
-async function probeFleetMountTablePresent(dir) {
-  try {
-    const text = await readFile("/proc/self/mounts", "utf8");
-    const resolved = path2.resolve(dir);
-    for (const raw of text.split("\n")) {
-      if (raw.length === 0) continue;
-      const fields = raw.split(/\s+/);
-      const mp = fields[1];
-      const fstype = fields[2];
-      if (!mp || !fstype) continue;
-      if (mp.replace(/\\040/g, " ") !== resolved) continue;
-      if (fstype !== "tmpfs") return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-var NOT_READY_SENTINEL = ".skaile-workspace-not-ready";
-var TARGET_ALREADY_PRESENT_CODES = /* @__PURE__ */ new Set(["EEXIST", "ENOTCONN", "EBUSY", "ENOTDIR"]);
-function errnoCode(err) {
-  return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
-}
-var SENTINEL_BODY = [
-  "This workspace is backed by a remote mount that is not live yet.",
-  "It is mounted read-only on purpose: writing here would create a phantom",
-  "workspace that diverges from the remote once the mount comes up.",
-  "Wait for the mount to finish syncing (watch connector_status) before writing.",
-  ""
-].join("\n");
-var defaultMkdir = async (target) => {
-  await mkdir(target, { recursive: true });
-};
-var defaultRunner = (cmd, args) => new Promise((resolve5, reject) => {
-  const proc = spawn(cmd, args, { stdio: "ignore" });
-  proc.once("error", reject);
-  proc.once("close", (code, signal) => {
-    if (code === 0) resolve5();
-    else reject(new Error(`${cmd} ${args.join(" ")} exited ${code ?? `signal ${signal}`}`));
-  });
-});
-var RoMountPlaceholderBarrier = class {
-  run;
-  mkdirFn;
-  modes = /* @__PURE__ */ new Map();
-  constructor(opts) {
-    this.run = opts?.run ?? defaultRunner;
-    this.mkdirFn = opts?.mkdirFn ?? defaultMkdir;
-  }
-  async establish(target, log) {
-    if (this.modes.has(target)) return;
-    try {
-      await this.mkdirFn(target);
-    } catch (err) {
-      const code = errnoCode(err);
-      if (!code || !TARGET_ALREADY_PRESENT_CODES.has(code)) {
-        await this.chmodFallback(target, err, log);
-        return;
-      }
-      log?.debug("barrier target already present (live/broken mount) \u2014 protecting in place", {
-        target,
-        code
-      });
-    }
-    let tmpfsMounted = false;
-    try {
-      await this.run("mount", [
-        "-t",
-        "tmpfs",
-        "-o",
-        "mode=0755,size=1m",
-        "skaile-not-ready",
-        target
-      ]);
-      tmpfsMounted = true;
-      await writeFile(path2.join(target, NOT_READY_SENTINEL), SENTINEL_BODY);
-      await this.run("mount", ["-o", "remount,ro", target]);
-      this.modes.set(target, "mount");
-      log?.info("deferred mount barrier established (read-only tmpfs)", { target });
-    } catch (err) {
-      if (tmpfsMounted) await this.run("umount", [target]).catch(() => {
-      });
-      await this.chmodFallback(target, err, log);
-    }
-  }
-  async prepareForStackedMount(target, log) {
-    const mode = this.modes.get(target);
-    if (mode === "mount") {
-      try {
-        await this.run("mount", ["-o", "remount,rw", target]);
-        log?.debug("deferred mount barrier lifted to read-write for stacked mount", { target });
-      } catch (err) {
-        log?.error(
-          "deferred mount barrier: remount read-write before stacked mount failed \u2014 the mount may be rejected with EACCES",
-          err instanceof Error ? err : void 0,
-          { target }
-        );
-      }
-      return;
-    }
-  }
-  async restoreBarrier(target, log) {
-    const mode = this.modes.get(target);
-    if (mode === "mount") {
-      let restored = false;
-      await this.run("mount", ["-o", "remount,ro", target]).then(() => {
-        restored = true;
-      }).catch((err) => {
-        log?.error(
-          "deferred mount barrier: remount read-only after failed mount failed \u2014 target may be writable",
-          err instanceof Error ? err : void 0,
-          { target }
-        );
-      });
-      if (restored) log?.debug("deferred mount barrier re-asserted read-only after failed mount", { target });
-    }
-  }
-  async onMountLive(target, log) {
-    const mode = this.modes.get(target);
-    if (mode === "mount") {
-      log?.debug("deferred mount live; placeholder shadowed", { target });
-      return;
-    }
-    if (mode === "chmod" || mode === "unprotected") {
-      if (mode === "chmod") await chmod(target, 493).catch(() => {
-      });
-      await rm(path2.join(target, NOT_READY_SENTINEL), { force: true }).catch(() => {
-      });
-      log?.debug("deferred mount live; degraded barrier lifted", { target, mode });
-    }
-  }
-  async exposeReadOnly(target, log) {
-    const mode = this.modes.get(target);
-    if (mode === "ro-bind") return;
-    if (mode === "mount") {
-      let unmounted = await this.run("umount", [target]).then(
-        () => true,
-        () => false
-      );
-      if (!unmounted) {
-        unmounted = await this.run("umount", ["-l", target]).then(
-          () => true,
-          () => false
-        );
-      }
-      if (!unmounted) {
-        log?.error(
-          "deferred mount barrier: could not unmount opaque mask to expose read-only surface \u2014 staying masked",
-          void 0,
-          { target }
-        );
-        return;
-      }
-    }
-    try {
-      await this.run("mount", ["--bind", target, target]);
-      await this.run("mount", ["-o", "remount,ro,bind", target]);
-      this.modes.set(target, "ro-bind");
-      log?.info("deferred mount barrier downgraded to read-only (content visible)", { target });
-    } catch (err) {
-      const chmodOk = await chmod(target, 365).then(
-        () => true,
-        () => false
-      );
-      this.modes.set(target, chmodOk ? "chmod" : "unprotected");
-      log?.error(
-        chmodOk ? "deferred mount read-only-readable surface degraded to chmod (ro bind unavailable) \u2014 a write by the owning uid could bypass it" : "deferred mount read-only-readable surface FAILED (ro bind and chmod both unavailable) \u2014 target may be writable",
-        err instanceof Error ? err : void 0,
-        { target }
-      );
-    }
-  }
-  isOpaque(target) {
-    return this.modes.get(target) === "mount";
-  }
-  async remove(target, log) {
-    const mode = this.modes.get(target);
-    if (!mode) return;
-    this.modes.delete(target);
-    if (mode === "mount" || mode === "ro-bind") {
-      let unmounted = false;
-      try {
-        await this.run("umount", [target]);
-        unmounted = true;
-      } catch {
-        await this.run("umount", ["-l", target]).then(
-          () => {
-            unmounted = true;
-          },
-          () => {
-          }
-        );
-      }
-      if (unmounted) {
-        log?.debug("deferred mount barrier removed (tmpfs unmounted)", { target });
-      } else {
-        log?.error(
-          "deferred mount barrier: umount and umount -l both failed \u2014 tmpfs may be leaked",
-          void 0,
-          { target }
-        );
-      }
-      return;
-    }
-    if (mode === "chmod") await chmod(target, 493).catch(() => {
-    });
-    await rm(path2.join(target, NOT_READY_SENTINEL), { force: true }).catch(() => {
-    });
-    log?.debug(
-      mode === "chmod" ? "deferred mount barrier removed (chmod restored)" : "deferred mount barrier removed (was never enforced \u2014 target stayed writable)",
-      { target }
-    );
-  }
-  async chmodFallback(target, cause, log) {
-    await writeFile(path2.join(target, NOT_READY_SENTINEL), SENTINEL_BODY).catch(() => {
-    });
-    const chmodOk = await chmod(target, 365).then(
-      () => true,
-      () => false
-    );
-    this.modes.set(target, chmodOk ? "chmod" : "unprotected");
-    const detail = { target, error: cause instanceof Error ? cause.message : String(cause) };
-    if (chmodOk) {
-      log?.error(
-        "deferred mount read-only barrier degraded to chmod (mount unavailable) \u2014 a write by the owning uid could bypass it",
-        void 0,
-        detail
-      );
-    } else {
-      log?.error(
-        "deferred mount read-only barrier FAILED (mount and chmod both unavailable) \u2014 target is WRITABLE",
-        void 0,
-        detail
-      );
-    }
-  }
-};
-var defaultMountPlaceholderBarrier = new RoMountPlaceholderBarrier();
-
 // connectors/src/connector-manager.ts
 var KNOWN_PREFIXES = ["env:", "forge:", "op:", "kp:", "oauth:"];
-var DEFAULT_FLEET_HEALTH_POLL_MS = 5e3;
-function parseFleetHealthPollMs(raw = process.env.SKAILE_FLEET_HEALTH_POLL_MS) {
-  if (raw === void 0) return DEFAULT_FLEET_HEALTH_POLL_MS;
-  const n = Number(raw);
-  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_FLEET_HEALTH_POLL_MS;
-}
 function hasKnownPrefix(ref) {
   return KNOWN_PREFIXES.some((p) => ref.startsWith(p));
 }
@@ -5960,9 +5080,6 @@ var ConnectorManager = class {
     this.catalogEntries = opts.catalogEntries ?? [];
     this.tokenMediator = opts.tokenMediator;
     this.preMintedSecrets = opts.preMintedSecrets;
-    this.placeholderBarrier = opts.placeholderBarrier ?? defaultMountPlaceholderBarrier;
-    this.fleetHealthPollMs = opts.fleetHealthPollMs ?? parseFleetHealthPollMs();
-    this.fleetMountRecoveryProbe = opts.fleetMountRecoveryProbe ?? probeFleetMountTablePresent;
     const secrets = opts.secrets;
     if (secrets && typeof secrets === "object" && "prepareRef" in secrets) {
       this.chain = secrets;
@@ -5985,20 +5102,9 @@ var ConnectorManager = class {
   catalogEntries;
   tokenMediator;
   preMintedSecrets;
-  placeholderBarrier;
   mgrLog;
-  /** Set once `disconnectAll()` starts, so in-flight deferred mounts bail. */
-  disposed = false;
   /** Aborted on dispose; threaded into every `connect()` via `ctx.abortSignal`. */
   disposeController = new AbortController();
-  /** Tracks the background task driving deferred (rclone-backed) mounts. */
-  deferredConnect;
-  /** Periodic local fleet-health probe; runs only while a fleet gate is active. */
-  fleetHealthTimer;
-  /** Local fleet-health poll interval (ms). 0 disables the local probe. */
-  fleetHealthPollMs;
-  /** Host-mount recovery detector under an opaque placeholder (injectable for tests). */
-  fleetMountRecoveryProbe;
   // ── Private helpers ──────────────────────────────────────────────────────────
   /**
    * Wrap the user-supplied `TokenMediator` so `reason: 'initial'` calls for an
@@ -6128,8 +5234,8 @@ var ConnectorManager = class {
   }
   /** Release every mount target owned by `id` (on disconnect). */
   releaseMountTarget(id) {
-    for (const [path3, owner] of [...this.mountTargets]) {
-      if (owner === id) this.mountTargets.delete(path3);
+    for (const [path, owner] of [...this.mountTargets]) {
+      if (owner === id) this.mountTargets.delete(path);
     }
   }
   /**
@@ -6193,21 +5299,13 @@ var ConnectorManager = class {
    * connector with a `mount` config failed → throws `ConnectorStartupError`
    * (fail-fast lifecycle semantics for mountable connectors).
    *
-   * When `options.deferMounts` is set, connectors whose filesystem face is
-   * marked `deferMount` (rclone-backed FUSE mounts) are NOT awaited here:
-   * their target is pre-registered (so the mount path renders in the system
-   * prompt immediately) and the actual mount is driven on a background task.
-   * The returned report therefore covers only the eagerly-connected set, so a
-   * slow remote can never gate whatever the caller does next (e.g. emitting
-   * `session_init_ack`). Deferred connectors surface their progress through
-   * `onStatusChange` (connecting → connected | error).
-   *
    * @param declarations - Connector declarations from `skaile.yaml`.
    * @param options.failOnReadWriteError - Throw `ConnectorStartupError` if any
    *   read-write connector fails. Read-only failures are always tolerated.
    *   Only the eager set is considered — deferred mounts never throw.
-   * @param options.deferMounts - Bring `deferMount` filesystem-face connectors
-   *   up in the background instead of awaiting them.
+   * @param options.deferMounts - Deprecated compatibility option. Cloud
+   *   connectors now require already-live host fleet bind mounts and connect
+   *   synchronously.
    */
   async connectAll(declarations, options) {
     this.mgrLog.info("connectAll start", { count: declarations.length });
@@ -6215,36 +5313,8 @@ var ConnectorManager = class {
       if (decl.mount != null) this.reserveMountTarget(decl.id, this.resolveMountTarget(decl));
     }
     const results = [];
-    const eager = [];
-    const deferred = [];
-    if (options?.deferMounts) {
-      for (const decl of declarations) {
-        let connector;
-        try {
-          connector = await this.resolveConnector(decl.driver);
-        } catch {
-        }
-        if (connector?.filesystem?.deferMount === true) {
-          deferred.push({ decl, connector });
-        } else {
-          eager.push({ decl, connector });
-        }
-      }
-    } else {
-      for (const decl of declarations) eager.push({ decl });
-    }
-    for (const { decl, connector } of eager) {
-      results.push(await this.attemptConnect(decl, connector));
-    }
-    if (deferred.length > 0) {
-      for (const { decl, connector } of deferred) {
-        await this.preRegisterDeferred(decl, connector);
-      }
-      const prior = this.deferredConnect;
-      this.deferredConnect = (async () => {
-        if (prior) await prior;
-        await this.connectDeferred(deferred);
-      })();
+    for (const decl of declarations) {
+      results.push(await this.attemptConnect(decl));
     }
     const report = { results };
     this.mgrLog.info("connectAll complete", {
@@ -6273,7 +5343,7 @@ var ConnectorManager = class {
   /**
    * Connect a single declaration, emitting `connecting` → `connected | error`.
    * Never throws — failures are recorded in the returned result so `connectAll`
-   * can keep going. Shared by the eager loop and the deferred background task.
+   * can keep going.
    */
   async attemptConnect(decl, preResolved) {
     this.opts.onStatusChange?.({
@@ -6299,20 +5369,10 @@ var ConnectorManager = class {
         },
         () => connector.connect(decl, ctx)
       );
-      const previous = this.active.get(decl.id);
-      if (previous?.watchHandle) {
-        try {
-          await previous.watchHandle.close();
-        } catch {
-        }
-      }
       this.active.set(decl.id, {
         connector,
         handle,
-        declaration: decl,
-        placeholderTarget: previous?.placeholderTarget,
-        fleetHealthGate: previous?.fleetHealthGate,
-        fleetHealthTarget: previous?.fleetHealthTarget
+        declaration: decl
       });
       this.opts.onStatusChange?.({
         type: "connector_status",
@@ -6343,216 +5403,26 @@ var ConnectorManager = class {
     }
   }
   /**
-   * Register a provisional entry for a deferred filesystem-face connector so
-   * its (deterministic) mount path shows up in `listConnectors()` / the system
-   * prompt before the background mount completes.
-   *
-   * Before exposing the target, a read-only barrier is established so the agent
-   * cannot write a phantom workspace into a not-yet-mounted remote.
-   *
-   * Fleet-managed mounts skip the *static* boot-time barrier (the host already
-   * bound the live share at the target — a static barrier would shadow real
-   * content) but instead get a *dynamic* health gate: while the host fleet rclone
-   * is healthy the target stays writable exactly as before; when it wedges, the
-   * gate establishes the same read-only barrier until the mount recovers.
-   */
-  async preRegisterDeferred(decl, connector) {
-    const mountTarget = this.resolveMountTarget(decl);
-    if (!existsSync(mountTarget)) mkdirSync(mountTarget, { recursive: true });
-    const fleetManaged = isFleetManaged(decl.id);
-    let placeholderTarget;
-    let fleetHealthGate;
-    let fleetHealthTarget;
-    if (fleetManaged) {
-      fleetHealthGate = new FleetHealthGate(mountTarget, this.placeholderBarrier, this.mgrLog);
-      fleetHealthTarget = mountTarget;
-    } else {
-      try {
-        await this.placeholderBarrier.establish(mountTarget, this.mgrLog);
-        placeholderTarget = mountTarget;
-      } catch (err) {
-        this.mgrLog.error("deferred mount barrier establish failed", err, { id: decl.id });
-      }
-    }
-    const handle = {
-      id: decl.id,
-      driver: connector.name ?? decl.driver,
-      access: decl.access,
-      status: "connecting",
-      mountPath: mountTarget,
-      // Empty (not null) so a best-effort disconnect of a still-provisional
-      // entry — e.g. a deferred mount that errored — finds no live handle and
-      // returns cleanly instead of dereferencing null state.
-      state: {}
-    };
-    this.active.set(decl.id, {
-      connector,
-      handle,
-      declaration: decl,
-      placeholderTarget,
-      fleetHealthGate,
-      fleetHealthTarget
-    });
-    if (fleetHealthGate) this.ensureFleetHealthPoll();
-  }
-  /**
-   * Start the periodic local fleet-health probe if it is not already running and
-   * the poll interval is enabled. Each tick probes every fleet target and feeds
-   * the verdict to its gate (hysteresis lives in the gate). The probe catches both
-   * directly-detectable failures (EIO / dead bind) AND host-mount recovery while a
-   * placeholder is up; silent degradation is covered by the platform signal via
-   * `reportFleetHealth`.
-   */
-  ensureFleetHealthPoll() {
-    if (this.fleetHealthTimer || this.fleetHealthPollMs <= 0 || this.disposed) return;
-    this.fleetHealthTimer = setInterval(() => {
-      void this.runFleetHealthProbe();
-    }, this.fleetHealthPollMs);
-    this.fleetHealthTimer.unref?.();
-  }
-  async runFleetHealthProbe() {
-    if (this.disposed) return;
-    const gates = [...this.active.values()].filter(
-      (e) => e.fleetHealthGate != null && e.fleetHealthTarget != null
-    );
-    await Promise.all(
-      gates.map(async (e) => {
-        const verdict = e.fleetHealthGate.isGated ? await this.probeGatedRecovery(e.fleetHealthGate) : await probeFleetHealth(e.fleetHealthTarget);
-        await e.fleetHealthGate.observe(verdict).catch(() => {
-        });
-      })
-    );
-  }
-  /**
-   * Detect host-mount RECOVERY for an already-gated target so the placeholder lifts
-   * edge-triggered (no restart). Over an opaque mask a stat/readdir reads the 0555
-   * mask and falsely reads healthy, so recovery is detected via the mount table;
-   * non-opaque surfaces hold their current surface until the platform signal lifts.
-   * Rationale: `_devlog/notes/2026-06-17-fleet-gate-edge-triggered-recovery.md`.
-   */
-  async probeGatedRecovery(gate) {
-    const target = gate.mountTarget;
-    if (!(this.placeholderBarrier.isOpaque?.(target) ?? false)) {
-      return gate.currentSurface === "ro" ? "degraded" : "error";
-    }
-    return await this.fleetMountRecoveryProbe(target) ? "healthy" : "error";
-  }
-  /**
-   * Feed an externally-derived fleet-health verdict for a connector into its gate.
-   *
-   * This is the consume side of the platform fleet-health signal: the host fleet
-   * health poll knows `core/stats.errors` and can detect a *silently-empty-but-
-   * writable* degraded mount that the local probe cannot. The runner watches the
-   * `<workspace>/.skaile/fleet-health/<connectorId>` flag and forwards its verdict
-   * here. Unknown / non-fleet ids are ignored.
-   *
-   * The verdict drives the gate across three surfaces (writable / read-only-
-   * readable / masked): `healthy` lifts any barrier, `degraded` downgrades to a
-   * read-only surface that keeps the live content visible, `error` keeps the
-   * opaque mask.
-   *
-   * A deferred remote mount may have been brought up with the *static* boot-time
-   * barrier (it was not fleet-managed at connect — e.g. the host bind landed
-   * late, after `connectAll` placed the not-ready barrier). When a fleet verdict
-   * later arrives for such a connector, a gate is created lazily over that same
-   * barrier (seeded `masked`, matching the static barrier already in place) so the
-   * authoritative platform signal can lift or downgrade it — otherwise a late-
-   * arriving live mount stays masked forever even after it goes healthy.
-   */
-  async reportFleetHealth(connectorId, verdict) {
-    const entry = this.active.get(connectorId);
-    if (!entry) return;
-    if (!entry.fleetHealthGate) {
-      if (!entry.placeholderTarget) return;
-      entry.fleetHealthTarget = entry.placeholderTarget;
-      entry.fleetHealthGate = new FleetHealthGate(
-        entry.placeholderTarget,
-        this.placeholderBarrier,
-        this.mgrLog,
-        { initialSurface: "masked" }
-      );
-    }
-    await entry.fleetHealthGate.observe(verdict).catch(() => {
-    });
-  }
-  /** Drive all deferred mounts concurrently; resolves when every one settles. */
-  async connectDeferred(deferred) {
-    await Promise.allSettled(
-      deferred.map(({ decl, connector }) => this.connectDeferredOne(decl, connector))
-    );
-  }
-  /**
-   * Background-connect one deferred mount. On success `attemptConnect` swaps the
-   * provisional entry for the real handle; on failure the provisional entry is
-   * marked `error` so the mount path keeps rendering as "still syncing". If the
-   * manager was disposed mid-flight, the connector that came up is torn down
-   * immediately so no rclone process leaks.
+   * Compatibility no-op for the removed in-container fleet health gate. Host
+   * fleet-managed cloud mounts are verified at connect time by their drivers.
    */
-  async connectDeferredOne(decl, connector) {
-    if (this.disposed) return;
-    const preEntry = this.active.get(decl.id);
-    if (preEntry?.placeholderTarget && this.placeholderBarrier.prepareForStackedMount) {
-      await this.placeholderBarrier.prepareForStackedMount(preEntry.placeholderTarget, this.mgrLog).catch(() => {
-      });
-    }
-    const result = await this.attemptConnect(decl, connector);
-    if (!result.connected) {
-      const entry2 = this.active.get(decl.id);
-      if (entry2 && entry2.handle.status === "connecting") entry2.handle.status = "error";
-      const failTarget = entry2?.placeholderTarget ?? preEntry?.placeholderTarget;
-      if (failTarget && this.placeholderBarrier.restoreBarrier) {
-        await this.placeholderBarrier.restoreBarrier(failTarget, this.mgrLog).catch(() => {
-        });
-      }
-      return;
-    }
-    const entry = this.active.get(decl.id);
-    if (entry?.placeholderTarget) {
-      await this.placeholderBarrier.onMountLive(entry.placeholderTarget, this.mgrLog).catch(() => {
-      });
-    }
-    if (this.disposed && this.active.has(decl.id)) {
-      await this.disconnect(decl.id).catch(() => {
-      });
-    }
+  async reportFleetHealth(_connectorId, _verdict) {
   }
   /**
-   * Resolve once every background (deferred) mount started by `connectAll` has
-   * settled. Resolves immediately when none are in flight. Useful for tests and
-   * for callers that want to await full readiness.
+   * Compatibility no-op for the removed deferred rclone mount path.
    */
   async whenDeferredMountsSettled() {
-    if (this.deferredConnect) await this.deferredConnect.catch(() => {
-    });
   }
   /** Disconnect all connectors and stop all watchers. Best-effort — ignores disconnect errors. */
   async disconnectAll() {
     this.mgrLog.info("disconnectAll start", { count: this.active.size });
-    this.disposed = true;
     this.disposeController.abort();
-    if (this.fleetHealthTimer) {
-      clearInterval(this.fleetHealthTimer);
-      this.fleetHealthTimer = void 0;
-    }
-    if (this.deferredConnect) {
-      try {
-        await this.deferredConnect;
-      } catch {
-      }
-      this.deferredConnect = void 0;
-    }
     await this.unwatchAll();
     for (const [id, entry] of this.active) {
       try {
         await entry.connector.disconnect(entry.handle);
       } catch {
       }
-      if (entry.placeholderTarget) {
-        await this.placeholderBarrier.remove(entry.placeholderTarget, this.mgrLog).catch(() => {
-        });
-      }
-      if (entry.fleetHealthGate) await entry.fleetHealthGate.dispose().catch(() => {
-      });
       this.opts.onStatusChange?.({
         type: "connector_status",
         connectorId: id,
@@ -6568,10 +5438,6 @@ var ConnectorManager = class {
    * Connect a single connector (hot-plug). Resolves fields and allocates
    * mount target if the connector has a filesystem face.
    *
-   * This path connects immediately and does NOT establish the read-only
-   * deferred-mount barrier — bring `deferMount` (rclone-backed) connectors up
-   * through `connectAll({ deferMounts: true })` so the not-ready guarantee holds.
-   *
    * @returns The `ConnectorHandle` for subsequent operations.
    */
   async connect(declaration) {
@@ -6641,12 +5507,6 @@ var ConnectorManager = class {
         try {
           await entry.connector.disconnect(entry.handle);
         } finally {
-          if (entry.placeholderTarget) {
-            await this.placeholderBarrier.remove(entry.placeholderTarget, this.mgrLog).catch(() => {
-            });
-          }
-          if (entry.fleetHealthGate) await entry.fleetHealthGate.dispose().catch(() => {
-          });
           this.active.delete(id);
           this.releaseMountTarget(id);
           this.opts.onStatusChange?.({
@@ -6822,7 +5682,7 @@ var ConnectorManager = class {
     }
     return entry.connector.tools;
   }
-  async read(id, path3) {
+  async read(id, path) {
     const entry = this.get(id);
     const tools = this.requireToolFace(id, entry);
     if (!tools.read) {
@@ -6835,10 +5695,10 @@ var ConnectorManager = class {
         "skaile.connector.driver": entry.connector.name,
         "skaile.connector.operation": "read"
       },
-      () => tools.read(entry.handle, path3)
+      () => tools.read(entry.handle, path)
     );
   }
-  async write(id, path3, content) {
+  async write(id, path, content) {
     const entry = this.get(id);
     if (entry.declaration.access === "read-only") {
       throw new Error(`Connector "${id}" is read-only`);
@@ -6854,10 +5714,10 @@ var ConnectorManager = class {
         "skaile.connector.driver": entry.connector.name,
         "skaile.connector.operation": "write"
       },
-      () => tools.write(entry.handle, path3, content)
+      () => tools.write(entry.handle, path, content)
     );
   }
-  async delete(id, path3) {
+  async delete(id, path) {
     const entry = this.get(id);
     if (entry.declaration.access === "read-only") {
       throw new Error(`Connector "${id}" is read-only`);
@@ -6873,10 +5733,10 @@ var ConnectorManager = class {
         "skaile.connector.driver": entry.connector.name,
         "skaile.connector.operation": "delete"
       },
-      () => tools.delete(entry.handle, path3)
+      () => tools.delete(entry.handle, path)
     );
   }
-  async list(id, path3, options) {
+  async list(id, path, options) {
     const entry = this.get(id);
     const tools = this.requireToolFace(id, entry);
     if (!tools.list) {
@@ -6889,7 +5749,7 @@ var ConnectorManager = class {
         "skaile.connector.driver": entry.connector.name,
         "skaile.connector.operation": "list"
       },
-      () => tools.list(entry.handle, path3, options)
+      () => tools.list(entry.handle, path, options)
     );
   }
   async search(id, query, options) {
@@ -7030,9 +5890,9 @@ async function buildSdkConnectorTools(manager, options) {
       connector_id: z4.string().describe("Connector ID"),
       path: z4.string().describe("Path within the connector")
     },
-    handler: async ({ connector_id, path: path3 }) => {
+    handler: async ({ connector_id, path }) => {
       try {
-        const content = await manager.read(connector_id, path3);
+        const content = await manager.read(connector_id, path);
         return {
           content: [{ type: "text", text: content?.data?.toString() ?? "(empty)" }]
         };
@@ -7054,11 +5914,11 @@ async function buildSdkConnectorTools(manager, options) {
     },
     handler: async ({
       connector_id,
-      path: path3,
+      path,
       content
     }) => {
       try {
-        await manager.write(connector_id, path3, { data: content });
+        await manager.write(connector_id, path, { data: content });
         return { content: [{ type: "text", text: "Written." }] };
       } catch (err) {
         return {
@@ -7078,11 +5938,11 @@ async function buildSdkConnectorTools(manager, options) {
     },
     handler: async ({
       connector_id,
-      path: path3,
+      path,
       recursive
     }) => {
       try {
-        const entries = await manager.list(connector_id, path3, { recursive });
+        const entries = await manager.list(connector_id, path, { recursive });
         return { content: [{ type: "text", text: JSON.stringify(entries, null, 2) }] };
       } catch (err) {
         return {
@@ -7118,9 +5978,9 @@ async function buildSdkConnectorTools(manager, options) {
       connector_id: z4.string().describe("Connector ID"),
       path: z4.string().describe("Path to delete")
     },
-    handler: async ({ connector_id, path: path3 }) => {
+    handler: async ({ connector_id, path }) => {
       try {
-        const ok = await manager.delete(connector_id, path3);
+        const ok = await manager.delete(connector_id, path);
         return { content: [{ type: "text", text: ok ? "Deleted." : "Not found." }] };
       } catch (err) {
         return {
@@ -7383,6 +6243,45 @@ printf 'password=%s\\n' "$pass"
 printf '\\n'
 `;
 }
+function isFleetManaged(connectorId) {
+  const raw = process.env.SKAILE_FLEET_MANAGED_MOUNTS ?? "";
+  if (raw.length === 0) return false;
+  return raw.split(",").map((segment) => segment.trim()).filter((segment) => segment.length > 0).includes(connectorId);
+}
+async function ensureFleetMounted(dir, log, options) {
+  const timeoutMs = options?.timeoutMs ?? 3e3;
+  const pollIntervalMs = options?.pollIntervalMs ?? 100;
+  const deadline = Date.now() + timeoutMs;
+  let lastErr = null;
+  while (Date.now() < deadline) {
+    try {
+      const st = await stat(dir);
+      if (!st.isDirectory()) {
+        throw new Error(`fleet mountpoint ${dir} is not a directory`);
+      }
+      await readdir(dir);
+      log.info("fleet bind mount verified", { dir });
+      return;
+    } catch (err) {
+      lastErr = err;
+      await new Promise((resolve5) => setTimeout(resolve5, pollIntervalMs));
+    }
+  }
+  throw new Error(
+    `fleet mount ${dir} not ready after ${timeoutMs}ms \u2014 check SKAILE_FLEET_MANAGED_MOUNTS env var and host bind: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+  );
+}
+async function ensureDirMode(dir, log) {
+  await mkdir(dir, { recursive: true });
+  try {
+    await chmod(dir, 504);
+  } catch (err) {
+    log?.debug("chmod 0770 skipped (EPERM \u2014 entrypoint heal expected)", {
+      path: dir,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
 
 // connectors/src/log-buffer.ts
 var LogBuffer = class {
@@ -7436,19 +6335,19 @@ var ManagedGitconfigCollisionError = class extends Error {
 var blockStart = (mountId) => `# skaile-mount: ${mountId}`;
 var blockEnd = (mountId) => `# skaile-mount: ${mountId} (end)`;
 var credentialTag = (mountId) => `# skaile-mount: ${mountId}`;
-function readFileOrEmpty(path3) {
+function readFileOrEmpty(path) {
   try {
-    return readFileSync(path3, "utf-8");
+    return readFileSync(path, "utf-8");
   } catch {
     return "";
   }
 }
-function atomicWrite(path3, content, mode) {
-  const dir = dirname(path3);
+function atomicWrite(path, content, mode) {
+  const dir = dirname(path);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true, mode: 448 });
   }
-  const tmp = `${path3}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+  const tmp = `${path}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   const fd = openSync(tmp, "w", mode);
   try {
     writeSync(fd, content);
@@ -7456,7 +6355,7 @@ function atomicWrite(path3, content, mode) {
     closeSync(fd);
   }
   chmodSync(tmp, mode);
-  renameSync(tmp, path3);
+  renameSync(tmp, path);
 }
 function appendForeignLine(blocks, line) {
   const last = blocks[blocks.length - 1];
@@ -7522,13 +6421,13 @@ function buildCredentialLine(urlPrefix, token, mountId) {
   const encodedToken = encodeURIComponent(token);
   return `${scheme}://x-access-token:${encodedToken}@${host} ${credentialTag(mountId)}`;
 }
-function readCredentialLines(path3) {
-  return readFileOrEmpty(path3).split("\n").filter((l) => l.length > 0);
+function readCredentialLines(path) {
+  return readFileOrEmpty(path).split("\n").filter((l) => l.length > 0);
 }
-function writeCredentialLines(path3, lines) {
+function writeCredentialLines(path, lines) {
   const content = lines.length > 0 ? `${lines.join("\n")}
 ` : "";
-  atomicWrite(path3, content, 416);
+  atomicWrite(path, content, 416);
 }
 function findExistingBlock(blocks, mountId) {
   return blocks.find((b) => b.mountId === mountId);
@@ -7632,156 +6531,191 @@ function isPackageResolvable(pkg, projectDir) {
 function findMissingPackages(packages, projectDir) {
   return packages.filter((p) => !isPackageResolvable(p, projectDir));
 }
-
-// connectors/src/rclone-token-refresh.ts
-var PROACTIVE_RCLONE_REFRESH_MARGIN_MS = 5 * 60 * 1e3;
-var DEFAULT_REACTIVE_COOLDOWN_MS = 30 * 1e3;
-var MAX_TIMER_MS = 2147483647;
-function createRcloneTokenRefresh(deps) {
-  const now2 = deps.now ?? (() => Date.now());
-  const setTimeoutImpl = deps.setTimeoutImpl ?? ((handler, ms) => setTimeout(handler, ms));
-  const clearTimeoutImpl = deps.clearTimeoutImpl ?? ((handle) => {
-    clearTimeout(handle);
-  });
-  const marginMs = deps.marginMs ?? PROACTIVE_RCLONE_REFRESH_MARGIN_MS;
-  const reactiveCooldownMs = deps.reactiveCooldownMs ?? DEFAULT_REACTIVE_COOLDOWN_MS;
-  let timer = null;
-  let refreshing = false;
-  let disposed = false;
-  let lastRefreshAt = Number.NEGATIVE_INFINITY;
-  function clearTimer() {
-    if (timer !== null) {
-      clearTimeoutImpl(timer);
-      timer = null;
-    }
-  }
-  function cancel() {
-    disposed = true;
-    clearTimer();
-  }
-  async function fire(reason) {
-    if (refreshing || disposed) return;
-    refreshing = true;
-    try {
-      let result;
-      try {
-        result = await deps.tokenMediator({ connectorId: deps.connectorId, reason });
-      } catch (err) {
-        deps.log(
-          `[rclone-token-refresh] mediator threw: ${err instanceof Error ? err.message : String(err)}; reactive auth-error path remains as safety net`
-        );
-        return;
-      }
-      if (disposed) return;
-      if (!result.ok) {
-        deps.log(
-          `[rclone-token-refresh] mediator refused (${result.code}: ${result.message}); reactive auth-error path remains as safety net`
-        );
-        return;
-      }
-      if (!result.token) {
-        deps.log(
-          "[rclone-token-refresh] mediator returned an empty token; reactive auth-error path remains as safety net"
-        );
-        return;
-      }
-      const handle = deps.handleRef.current;
-      if (!handle) {
-        deps.log("[rclone-token-refresh] no live rclone handle to recycle; skipping refresh");
-        return;
-      }
-      const rcloneConfig = await deps.renderConfig(result.token);
-      if (disposed) return;
-      let next;
-      try {
-        next = await deps.rclone.reconfigure(handle, rcloneConfig);
-      } catch (err) {
-        deps.log(
-          `[rclone-token-refresh] reconfigure failed: ${err instanceof Error ? err.message : String(err)}; reactive auth-error path remains as safety net`
-        );
-        return;
+var PortPool = class _PortPool {
+  min;
+  max;
+  inUse = /* @__PURE__ */ new Set();
+  constructor(range) {
+    this.min = range[0];
+    this.max = range[1];
+  }
+  /** Allocate the next free port from the range. Checks OS for collisions. */
+  async allocate() {
+    for (let port = this.min; port <= this.max; port++) {
+      if (this.inUse.has(port)) continue;
+      if (!await _PortPool.isPortFree(port)) {
+        this.inUse.add(port);
+        continue;
       }
-      if (disposed) {
-        deps.log("[rclone-token-refresh] disposed mid-recycle; stopping freshly-spawned process");
-        try {
-          await deps.rclone.stop(next);
-        } catch {
+      this.inUse.add(port);
+      return port;
+    }
+    throw new Error(`No free port in range ${this.min}-${this.max}`);
+  }
+  /** Mark a port as in-use (for explicit port args or registered instances). */
+  reserve(port) {
+    this.inUse.add(port);
+  }
+  /** Return a port to the pool. */
+  release(port) {
+    this.inUse.delete(port);
+  }
+  /** Check if a port is currently tracked as in-use. */
+  isInUse(port) {
+    return this.inUse.has(port);
+  }
+  /** Quick TCP connect test — returns true if nothing is listening. */
+  static isPortFree(port, host = "127.0.0.1") {
+    return new Promise((resolve5) => {
+      const socket = createConnection({ port, host });
+      socket.once("connect", () => {
+        socket.destroy();
+        resolve5(false);
+      });
+      socket.once("error", () => {
+        socket.destroy();
+        resolve5(true);
+      });
+      socket.setTimeout(500, () => {
+        socket.destroy();
+        resolve5(true);
+      });
+    });
+  }
+};
+function globToMatcher(pattern) {
+  const segmentMatch = pattern.match(/^\*\*\/([^*/?]+)\/\*\*$/);
+  if (segmentMatch) {
+    const name = segmentMatch[1];
+    return (p) => p.includes(`/${name}/`) || p.endsWith(`/${name}`) || p === name;
+  }
+  const dotSegment = pattern.match(/^\*\*\/(\.[\w#]+)(?:\/\*\*)?$/);
+  if (dotSegment) {
+    const name = dotSegment[1];
+    return (p) => p.includes(`/${name}/`) || p.endsWith(`/${name}`) || p === name;
+  }
+  const extMatch = pattern.match(/^\*\*\/\*(\.\w+(?:\.\*)?)/);
+  if (extMatch) {
+    const suffix = extMatch[1];
+    if (suffix.endsWith(".*")) {
+      const base = suffix.slice(0, -2);
+      return (p) => p.includes(base);
+    }
+    return (p) => p.endsWith(suffix);
+  }
+  const suffixMatch = pattern.match(/^\*\*\/\*(.+)$/);
+  if (suffixMatch) {
+    const sfx = suffixMatch[1];
+    return (p) => p.endsWith(sfx);
+  }
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  const re = new RegExp(`^${escaped}$`);
+  return (p) => re.test(p);
+}
+var DEFAULT_IGNORED = [
+  (p) => p.includes("/.git/") || p.endsWith("/.git"),
+  (p) => p.includes("/node_modules/") || p.endsWith("/node_modules"),
+  (p) => p.includes("/.connectors/") || p.endsWith("/.connectors"),
+  // Atomic-write tempfiles (Bun.write creates `<name>.tmp.<pid>.<ts>` then renames).
+  // These vanish between readdir and fs.watch, causing EINVAL that crashes the process.
+  (p) => /\.tmp\.\d/.test(p),
+  // Editor swap/backup files that also race with save operations.
+  (p) => p.endsWith(".swp"),
+  (p) => p.endsWith(".swx"),
+  (p) => p.includes("/.#"),
+  (p) => p.endsWith("~")
+];
+var DEFAULT_DEBOUNCE_MS = 150;
+function parseGitignore(rootDir) {
+  const gitignorePath = join(rootDir, ".gitignore");
+  if (!existsSync(gitignorePath)) return [];
+  try {
+    const content = readFileSync(gitignorePath, "utf-8");
+    const matchers = [];
+    for (const raw of content.split("\n")) {
+      const line = raw.trim();
+      if (!line || line.startsWith("#") || line.startsWith("!")) continue;
+      let pattern = line;
+      if (pattern.startsWith("/")) {
+        pattern = pattern.slice(1);
+      } else if (!pattern.includes("/")) {
+        pattern = `**/${pattern}`;
+      }
+      if (pattern.endsWith("/")) {
+        matchers.push(globToMatcher(`${pattern}**`));
+      } else {
+        matchers.push(globToMatcher(pattern));
+        if (!pattern.includes("*") && !pattern.includes(".")) {
+          matchers.push(globToMatcher(`${pattern}/**`));
         }
-        return;
       }
-      deps.handleRef.current = next;
-      lastRefreshAt = now2();
-      deps.log(
-        `[rclone-token-refresh] recycled mount with refreshed token (reason=${reason}, expiresAt=${result.expiresAt ?? "none"})`
-      );
-      schedule(result.expiresAt);
-    } finally {
-      refreshing = false;
-    }
-  }
-  function armTimer(fireAtMs) {
-    const delayMs = Math.min(Math.max(0, fireAtMs - now2()), MAX_TIMER_MS);
-    timer = setTimeoutImpl(() => {
-      timer = null;
-      if (now2() < fireAtMs) armTimer(fireAtMs);
-      else void fire("refresh");
-    }, delayMs);
-    timer.unref?.();
-  }
-  function schedule(expiresAtIso) {
-    clearTimer();
-    if (disposed || !expiresAtIso) return;
-    const expiresAtMs = Date.parse(expiresAtIso);
-    if (!Number.isFinite(expiresAtMs)) return;
-    const fireAtMs = expiresAtMs - marginMs;
-    if (fireAtMs - now2() <= 0) {
-      deps.log(`[rclone-token-refresh] token within ${marginMs / 1e3}s of expiry; refreshing now`);
-    } else {
-      deps.log(
-        `[rclone-token-refresh] scheduled in ${Math.round((fireAtMs - now2()) / 1e3)}s (expiresAt=${expiresAtIso})`
-      );
     }
-    armTimer(fireAtMs);
+    return matchers;
+  } catch {
+    return [];
   }
-  function onAuthError() {
-    if (refreshing || disposed) return;
-    if (now2() - lastRefreshAt < reactiveCooldownMs) {
-      deps.log(
-        "[rclone-token-refresh] auth-error within refresh cooldown; suppressing reactive refresh"
-      );
-      return;
-    }
-    clearTimer();
-    void fire("retry-401");
+}
+var CHOKIDAR_EVENT_MAP = {
+  add: "create",
+  change: "edit",
+  unlink: "delete",
+  addDir: "create",
+  unlinkDir: "delete"
+};
+async function createFsWatcher(rootDir, callback, options) {
+  const log = createLogger({ kind: "connector", subkind: "watcher", instance: rootDir });
+  const gitignorePatterns = parseGitignore(rootDir);
+  const optionsIgnored = (options?.ignored ?? []).map(
+    (entry) => typeof entry === "string" ? globToMatcher(entry) : entry
+  );
+  const ignored = [...DEFAULT_IGNORED, ...gitignorePatterns, ...optionsIgnored];
+  const debounceMs = options?.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  const watcher = chokidar.watch(rootDir, {
+    ignoreInitial: true,
+    ignored,
+    awaitWriteFinish: { stabilityThreshold: debounceMs, pollInterval: 50 },
+    usePolling: false
+  });
+  watcher.on("error", (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    log.warn("watcher error (non-fatal)", { message });
+  });
+  for (const [chokidarEvent, action] of Object.entries(CHOKIDAR_EVENT_MAP)) {
+    watcher.on(
+      chokidarEvent,
+      (fullPath) => {
+        const rel = relative(rootDir, fullPath);
+        if (!rel || rel.startsWith("..")) return;
+        const normalizedPath = rel.split("\\").join("/");
+        callback({ path: normalizedPath, action, source: "filesystem" });
+      }
+    );
   }
   return {
-    schedule,
-    onAuthError,
-    cancel,
-    isPending: () => timer !== null
+    close: () => watcher.close()
   };
 }
 var WorktreeRegistryImpl = class {
   entries = /* @__PURE__ */ new Map();
-  register(path3, owner) {
-    let owners = this.entries.get(path3);
+  register(path, owner) {
+    let owners = this.entries.get(path);
     if (!owners) {
       owners = /* @__PURE__ */ new Set();
-      this.entries.set(path3, owners);
+      this.entries.set(path, owners);
     }
     owners.add(owner);
   }
-  deregister(path3, owner) {
-    const owners = this.entries.get(path3);
+  deregister(path, owner) {
+    const owners = this.entries.get(path);
     if (!owners) return;
     owners.delete(owner);
-    if (owners.size === 0) this.entries.delete(path3);
+    if (owners.size === 0) this.entries.delete(path);
   }
-  isInUse(path3) {
-    return (this.entries.get(path3)?.size ?? 0) > 0;
+  isInUse(path) {
+    return (this.entries.get(path)?.size ?? 0) > 0;
   }
-  owners(path3) {
-    return [...this.entries.get(path3) ?? []];
+  owners(path) {
+    return [...this.entries.get(path) ?? []];
   }
 };
 var worktreeRegistry = new WorktreeRegistryImpl();
@@ -7910,8 +6844,8 @@ var FlowAdapter = class extends AbstractConnector {
   constructor() {
     super();
     this.tools = {
-      read: (handle, path3) => this.read(handle, path3),
-      list: (handle, path3, options) => this.list(handle, path3, options),
+      read: (handle, path) => this.read(handle, path),
+      list: (handle, path, options) => this.list(handle, path, options),
       search: (handle, query, options) => this.search(handle, query, options),
       describeOperations: (handle) => this.describeOperations(handle),
       executeOp: (handle, operation, args) => this.executeOp(handle, operation, args)
@@ -7955,16 +6889,16 @@ var FlowAdapter = class extends AbstractConnector {
     s.execution = this.recompute(s);
   }
   // ── Base operations (private — wired into tools face in constructor) ──
-  async read(handle, path3) {
+  async read(handle, path) {
     const s = this.s(handle);
-    if (path3 === "" || path3 === "state") {
+    if (path === "" || path === "state") {
       return {
         data: JSON.stringify(s.execution, null, 2),
         contentType: "application/json"
       };
     }
-    if (path3.startsWith("node/")) {
-      const nodeId = path3.slice(5);
+    if (path.startsWith("node/")) {
+      const nodeId = path.slice(5);
       const node = s.flowDef.nodes.find((n) => n.id === nodeId);
       if (!node) return null;
       const exec = s.execution.nodes[nodeId];
@@ -8781,6 +7715,6 @@ function createConnector() {
   return new FlowAdapter();
 }
 
-export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, ConnectorFieldMissingError, ConnectorManager, ConnectorStartupError, DEFAULT_REACTIVE_COOLDOWN_MS, DeployConnector, DevServerConnector, FleetHealthGate, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, NOT_READY_SENTINEL, PROACTIVE_RCLONE_REFRESH_MARGIN_MS, PostgresConnector, RoMountPlaceholderBarrier, S3Connector, SQLiteConnector, SharePointConnector, StaticServerConnector, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, __test, atomicReplaceCredential, buildConnectorPromptSection, buildSdkConnectorTools, createConnector, createConnector10, createConnector11, createConnector12, createConnector13, createConnector14, createConnector15, createConnector16, createConnector17, createConnector18, createConnector19, createConnector2, createConnector3, createConnector4, createConnector5, createConnector6, createConnector7, createConnector8, createConnector9, createRcloneTokenRefresh, createWorktree, defaultMountPlaceholderBarrier, defaultSpawn, ensureFleetMounted, findGitRoot, findMissingPackages, getConnector, installNpmPackages, isFleetManaged, isPackageResolvable, listConnectors, listWorktrees, probeFleetHealth, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock };
-//# sourceMappingURL=chunk-QLLFCQU5.js.map
-//# sourceMappingURL=chunk-QLLFCQU5.js.map
+export { AbstractConnector, BUILTIN_CONNECTOR_CATALOG, ConnectorFieldMissingError, ConnectorManager, ConnectorStartupError, DeployConnector, DevServerConnector, FlowAdapter, GitConnector, GmailConnector, GoogleDriveConnector, LocalConnector, LogBuffer, ManagedGitconfigCollisionError, MattermostConnector, MemoryConnector, MinIOConnector, PortPool, PostgresConnector, S3Connector, SQLiteConnector, SharePointConnector, StaticServerConnector, TunnelConnector, WebDAVConnector, XStateConnector, XStateStoreConnector, __test, atomicReplaceCredential, buildConnectorPromptSection, buildSdkConnectorTools, createConnector, createConnector10, createConnector11, createConnector12, createConnector13, createConnector14, createConnector15, createConnector16, createConnector17, createConnector18, createConnector19, createConnector2, createConnector3, createConnector4, createConnector5, createConnector6, createConnector7, createConnector8, createConnector9, createFsWatcher, createWorktree, defaultSpawn, ensureDirMode, ensureFleetMounted, findGitRoot, findMissingPackages, getConnector, installNpmPackages, isFleetManaged, isPackageResolvable, listConnectors, listWorktrees, readGitSyncStatus, registerBuiltinConnectors, removeMountBlock, renderCredentialHelperScript, tryGetConnector, worktreeRegistry, writeHelperScript, writeMountBlock };
+//# sourceMappingURL=chunk-WSQ5J7CE.js.map
+//# sourceMappingURL=chunk-WSQ5J7CE.js.map