@bevel-software/platform-core-backend 0.14.0 → 0.15.1

package/src/modules/tool-manuals/mcp-json-discovery.ts

@@ -195,6 +195,121 @@ export function validatedVariables(raw: unknown): ToolVariable[] | null {
  * materialization is a later phase — so a stdio server relying on them will
  * fail to spawn until then; bare-command servers (`npx …`) work today.
  */
+/**
+ * The ONE judgement of an `mcp.json` server entry — its name and its
+ * transport — shared by the manual scanner (which layers the platform's
+ * extension data and its reachability gate on top), the bundle dialect's
+ * registry (whose configs become entries) and the marketplace compiler
+ * (which ships only what a client could run). An entry that fails here fails
+ * everywhere, for one reason; an entry that passes is returned NORMALISED to
+ * the portable shape every consumer emits.
+ */
+export type McpEntryVerdict =
+  | { ok: true; transport: 'stdio'; entry: PortableStdioEntry }
+  | { ok: true; transport: 'streamable-http'; entry: PortableHttpEntry }
+  | { ok: false; reason: string };
+
+/** A stdio server as a client launches it — every field already the type the launcher needs. */
+export interface PortableStdioEntry {
+  type: 'stdio';
+  command: string;
+  args: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+}
+/** An http server as a client dials it — an endpoint, never a credential. */
+export interface PortableHttpEntry {
+  type: 'streamable-http';
+  url: string;
+  headers?: Record<string, string>;
+}
+
+/**
+ * A record whose every value is a string, or null — no coercion, no cast.
+ * Built without a prototype: the keys are HTTP header and environment
+ * variable names, and a plain object would silently swallow one spelled
+ * `__proto__` (a prototype assignment, not a property) — every accepted key
+ * must come out the other side.
+ */
+function stringMap(v: unknown): Record<string, string> | null {
+  if (!isRecord(v)) return null;
+  const out: Record<string, string> = Object.create(null) as Record<string, string>;
+  for (const [k, val] of Object.entries(v)) {
+    if (typeof val !== 'string') return null;
+    out[k] = val;
+  }
+  return out;
+}
+
+export function judgeMcpServerEntry(name: string, raw: unknown): McpEntryVerdict {
+  // The name rule (lowercase, alphanumeric first) also keeps every object
+  // prototype key — `__proto__`, `constructor` — out of the plain-object
+  // maps consumers build from these names.
+  if (!SERVER_NAME_RE.test(name)) {
+    return {
+      ok: false,
+      reason: 'the name is the secret namespace and route slug, so it must be lowercase alphanumeric with `_`/`-`',
+    };
+  }
+  if (!isRecord(raw) || typeof raw.type !== 'string') return { ok: false, reason: 'no transport type' };
+  if (raw.type === 'stdio') {
+    if (typeof raw.command !== 'string' || raw.command.length === 0) return { ok: false, reason: 'no command' };
+    const entry: PortableStdioEntry = { type: 'stdio', command: raw.command, args: [] };
+    if (raw.args !== undefined) {
+      // A launcher gets the strings it was given, never a stringified object.
+      if (!Array.isArray(raw.args) || !raw.args.every((a) => typeof a === 'string')) {
+        return { ok: false, reason: 'args must be a list of strings' };
+      }
+      entry.args = raw.args;
+    }
+    if (raw.env !== undefined) {
+      const env = stringMap(raw.env);
+      if (env === null) return { ok: false, reason: 'env must be a map of strings' };
+      entry.env = env;
+    }
+    if (raw.cwd !== undefined) {
+      if (typeof raw.cwd !== 'string') return { ok: false, reason: 'cwd must be a string' };
+      entry.cwd = raw.cwd;
+    }
+    return { ok: true, transport: 'stdio', entry };
+  }
+  if (raw.type === 'sse') {
+    // The pinned `@utcp/mcp` speaks `stdio` and streamable `http` — there
+    // is no sse transport in its schema, so a declaration claiming one either
+    // fails validation or, worse, dials a handshake the server does not
+    // speak. Refusing names the fix; silently rebuilding as http used to
+    // configure exactly that wrong handshake.
+    return {
+      ok: false,
+      reason: 'the MCP client has no `sse` transport — declare the server as `streamable-http` if it supports it',
+    };
+  }
+  if (raw.type === 'streamable-http') {
+    if (typeof raw.url !== 'string' || raw.url.length === 0) return { ok: false, reason: 'no url' };
+    let parsed: URL;
+    try {
+      parsed = new URL(raw.url);
+    } catch {
+      return { ok: false, reason: 'url must be http(s)' };
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return { ok: false, reason: 'url must be http(s)' };
+    // A portable entry is an endpoint. A credential belongs in the vault and
+    // reaches a client through the platform, never verbatim in a config that
+    // is compiled into a marketplace and cloned onto every member's machine.
+    if (parsed.username || parsed.password) return { ok: false, reason: 'url must not carry credentials' };
+    const entry: PortableHttpEntry = { type: 'streamable-http', url: raw.url };
+    if (raw.headers !== undefined) {
+      const headers = stringMap(raw.headers);
+      if (headers === null) return { ok: false, reason: 'headers must be a map of strings' };
+      entry.headers = headers;
+    }
+    return { ok: true, transport: 'streamable-http', entry };
+  }
+  // Unknown transport: the spec says an unknown `type` invalidates the
+  // ENTRY, not the file — the caller skips it and keeps its siblings.
+  return { ok: false, reason: `unknown type "${raw.type}"` };
+}
+
 export function descriptorsFromMcpJson(
   pluginFolder: string,
   mcpJsonText: string,
@@ -227,18 +342,14 @@ export function descriptorsFromMcpJson(
   const mcpJsonPath = `${PLUGINS_DIR}/${pluginFolder}/${PLUGIN_MCP_FILE}`;
 
   const out: ToolManualDescriptor[] = [];
-  for (const [name, raw] of Object.entries(mcp.mcpServers)) {
-    if (!SERVER_NAME_RE.test(name)) {
-      console.warn(
-        `[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: the name is the secret ` +
-          'namespace and route slug, so it must be lowercase alphanumeric with `_`/`-`.',
-      );
-      continue;
-    }
-    if (!isRecord(raw) || typeof raw.type !== 'string') {
-      console.warn(`[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: no transport type.`);
+  for (const [name, rawEntry] of Object.entries(mcp.mcpServers)) {
+    const verdict = judgeMcpServerEntry(name, rawEntry);
+    if (!verdict.ok) {
+      console.warn(`[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: ${verdict.reason}.`);
       continue;
     }
+    // Narrowed by the verdict: an entry that passed is a record.
+    const raw = rawEntry as Record<string, unknown>;
     // The extension entry is knowledge-base content too — same zero-trust
     // parse as the rest: a non-object entry reads as "no extension data".
     const ext: HexisMcpServerExtension = isRecord(extensions[name])
@@ -274,91 +385,46 @@ export function descriptorsFromMcpJson(
       ...(variables.length > 0 ? { variables } : {}),
     };
 
-    if (raw.type === 'stdio') {
-      if (typeof raw.command !== 'string' || raw.command.length === 0) {
-        console.warn(`[tool-manuals] skipping stdio server "${name}" in ${mcpJsonPath}: no command.`);
-        continue;
-      }
-      out.push({
-        ...shared,
-        remote: false,
-        stdio: {
-          command: raw.command,
-          args: Array.isArray(raw.args) ? raw.args.map(String) : [],
-          env: isRecord(raw.env) ? (raw.env as Record<string, string>) : undefined,
-          cwd: typeof raw.cwd === 'string' ? raw.cwd : undefined,
-        },
-      });
-      continue;
-    }
-
-    if (raw.type === 'sse') {
-      // The pinned `@utcp/mcp` speaks `stdio` and streamable `http` — there
-      // is no sse transport in its schema, so a template claiming one either
-      // fails validation or, worse, dials a handshake the server does not
-      // speak. Refusing here names the fix; silently rebuilding as http used
-      // to configure exactly that wrong handshake.
-      console.warn(
-        `[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: the MCP client has no \`sse\` transport — declare the server as \`streamable-http\` if it supports it.`,
-      );
+    if (verdict.transport === 'stdio') {
+      const { command, args, env, cwd } = verdict.entry;
+      out.push({ ...shared, remote: false, stdio: { command, args, env, cwd } });
       continue;
     }
 
-    if (raw.type === 'streamable-http') {
-      if (typeof raw.url !== 'string' || raw.url.length === 0) {
-        console.warn(`[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: no url.`);
-        continue;
-      }
-      // Remote-capable servers get the same SSRF gate `.tool` urls pass —
-      // otherwise mcp.json becomes the way to point the backend at loopback,
-      // private ranges, or the cloud metadata endpoint. A `local: true` entry
-      // is exempt because loopback is exactly what local MEANS, and only the
-      // user's own machine ever dials it.
-      // Scheme first, for EVERYONE: `local: true` exempts a server from the
-      // private-network reachability policy, not from being http(s) at all.
-      let schemeOk = false;
+    const url = verdict.entry.url;
+    // Remote-capable servers get the same SSRF gate `.tool` urls pass —
+    // otherwise mcp.json becomes the way to point the backend at loopback,
+    // private ranges, or the cloud metadata endpoint. A `local: true` entry
+    // is exempt because loopback is exactly what local MEANS, and only the
+    // user's own machine ever dials it. (The scheme itself was judged for
+    // everyone above: `local: true` exempts a server from the reachability
+    // policy, not from being http(s) at all.)
+    if (ext.local !== true) {
       try {
-        const u = new URL(raw.url);
-        schemeOk = u.protocol === 'http:' || u.protocol === 'https:';
-      } catch {
-        schemeOk = false;
-      }
-      if (!schemeOk) {
-        console.warn(`[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: url must be http(s).`);
+        assertSafeFetchUrl(url, { label: `mcp server "${name}" url` });
+      } catch (err) {
+        console.warn(
+          `[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: ` +
+            `${err instanceof Error ? err.message : String(err)} (declare it \`local: true\` if it is deliberately private).`,
+        );
         continue;
       }
-      if (ext.local !== true) {
-        try {
-          assertSafeFetchUrl(raw.url, { label: `mcp server "${name}" url` });
-        } catch (err) {
-          console.warn(
-            `[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: ` +
-              `${err instanceof Error ? err.message : String(err)} (declare it \`local: true\` if it is deliberately private).`,
-          );
-          continue;
-        }
-      }
-      // Extension headers (auth, `${VAR}` refs) win over mcp.json's literal
-      // ones on a key collision: the portable file cannot carry a credential,
-      // so when both name the same header the extension is the operative one.
-      // Both sides pass the isRecord gate — spreading a malformed non-object
-      // value (a string, say) would scatter its indices into header keys.
-      const headers = {
-        ...(isRecord(raw.headers) ? (raw.headers as Record<string, string>) : {}),
-        ...(isRecord(ext.headers) ? (ext.headers as Record<string, string>) : {}),
-      };
-      out.push({
-        ...shared,
-        url: raw.url,
-        ...(Object.keys(headers).length > 0 ? { headers } : {}),
-        ...(ext.local === true ? { remote: false } : {}),
-      });
-      continue;
     }
-
-    // Unknown transport: the spec says an unknown `type` invalidates the
-    // ENTRY, not the file — skip it, keep its siblings.
-    console.warn(`[tool-manuals] skipping mcp server "${name}" in ${mcpJsonPath}: unknown type "${raw.type}".`);
+    // Extension headers (auth, `${VAR}` refs) win over mcp.json's literal
+    // ones on a key collision: the portable file cannot carry a credential,
+    // so when both name the same header the extension is the operative one.
+    // Both sides pass the isRecord gate — spreading a malformed non-object
+    // value (a string, say) would scatter its indices into header keys.
+    const headers = {
+      ...(verdict.entry.headers ?? {}),
+      ...(isRecord(ext.headers) ? (ext.headers as Record<string, string>) : {}),
+    };
+    out.push({
+      ...shared,
+      url,
+      ...(Object.keys(headers).length > 0 ? { headers } : {}),
+      ...(ext.local === true ? { remote: false } : {}),
+    });
   }
   return out;
 }

package/src/modules/tool-manuals/tool-manuals.service.ts

@@ -15,10 +15,10 @@ import {
 import {
   DEFAULT_BRANCH,
   PLUGINS_DIR,
-  PLUGIN_MANIFEST_FILE,
-  PLUGIN_MCP_FILE,
 } from '@bevel-software/platform-shared';
 import { descriptorsFromMcpJson } from './mcp-json-discovery.js';
+import type { PluginSource } from '../plugins/discovery/plugin-source.js';
+import { KbPluginSource } from '../plugins/discovery/kb-plugin-source.js';
 import type { WorkspaceService } from '../workspace/workspace.service.js';
 import { workspaceIdForBranch } from '../../shared/workspace-id.js';
 import type { IAccessControl } from '../access/access-control.interface.js';
@@ -150,6 +150,8 @@ export class ToolManualService implements IToolManualService {
     private readonly accessControl: IAccessControl,
     private readonly kbDirName: string,
     now: () => number = Date.now,
+    /** Where plugins (and their MCP servers) come from — native manifests unless a dialect is configured. */
+    private readonly source: PluginSource = new KbPluginSource(),
   ) {
     this.cache = new TtlCache(CACHE_TTL_MS, now);
   }
@@ -425,12 +427,15 @@ export class ToolManualService implements IToolManualService {
   private async scan(): Promise<ToolManualDescriptor[]> {
     const cached = this.cache.get();
     if (cached) return cached;
+    // See `TtlCache.begin`: taken before the read so an `invalidate()` that
+    // lands mid-scan discards this result instead of being overwritten by it.
+    const token = this.cache.begin();
     const manuals = await this.scanDisk();
     await this.decorateMcpOAuth(manuals);
     // AFTER the oauth decoration, so an injected `${MCP_OAUTH}` header ref is
     // already declared and isn't re-surfaced as a bare admin key.
     for (const m of manuals) this.surfaceReferencedVariables(m);
-    this.cache.set(manuals);
+    this.cache.set(manuals, token);
     return manuals;
   }
 
@@ -654,27 +659,13 @@ export class ToolManualService implements IToolManualService {
     // shape. Listed BEFORE the `.tool` files: on a name collision (a legacy
     // mcp `.tool` the migration has not converted yet), the shared dedup keeps
     // the first occurrence, and the authoritative source must be the one kept.
+    // The plugins (and their mcp.json text) come from the configured source, so
+    // a dialect that expands servers from a registry lands here unchanged.
     const parsed: ToolManualDescriptor[] = [];
-    let pluginFolders: string[] = [];
-    try {
-      pluginFolders = (await fs.readdir(root, { withFileTypes: true }))
-        .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
-        .map((e) => e.name)
-        .sort();
-    } catch {
-      /* no Plugins/ root — nothing to scan */
-    }
-    for (const folder of pluginFolders) {
-      let mcpJson: string;
-      try {
-        mcpJson = await fs.readFile(path.join(root, folder, PLUGIN_MCP_FILE), 'utf-8');
-      } catch {
-        continue; // no mcp.json is the common case, not an error
-      }
-      const pluginJson = await fs
-        .readFile(path.join(root, folder, PLUGIN_MANIFEST_FILE), 'utf-8')
-        .catch(() => null);
-      parsed.push(...descriptorsFromMcpJson(folder, mcpJson, pluginJson));
+    const discovered = await this.source.discover(kbRoot);
+    for (const plugin of discovered.plugins) {
+      if (plugin.mcpJsonText === null) continue; // no servers is the common case, not an error
+      parsed.push(...descriptorsFromMcpJson(plugin.relFolder, plugin.mcpJsonText, plugin.manifestText));
     }
 
     for (const f of files) {

package/src/modules/workflow/__tests__/preserve-roles-yaml.test.ts

@@ -80,7 +80,7 @@ describe('mergeChangeRequest — roles.yaml preservation guard', () => {
 
     const git = {
       fetch: vi.fn().mockResolvedValue(undefined),
-      pull: vi.fn().mockResolvedValue(undefined),
+      pull: vi.fn().mockResolvedValue({ treeChanged: true }),
       // Resolve roles.yaml at origin/<ref> from the per-test content.
       readFileAtRef: vi.fn(async (_ws: string, ref: string) =>
         ref === `origin/${BASE}` ? opts.baseRoles : ref === `origin/${HEAD}` ? opts.headRoles : null,

package/src/modules/workflow/__tests__/workflow.service.commitFileWhileLocked.test.ts

@@ -83,6 +83,7 @@ function makeGit(overrides: Partial<{
     }),
     pull: vi.fn().mockImplementation(async () => {
       if (pullBehavior === 'fail') throw new Error('git pull failed: merge conflict');
+      return { treeChanged: true };
     }),
   } as unknown as GitService;
 }

package/src/modules/workflow/__tests__/workflow.service.facade.test.ts

@@ -182,7 +182,7 @@ function makeGit(): GitService {
     commit: vi.fn(),
     push: vi.fn(),
     fetch: vi.fn(),
-    pull: vi.fn(),
+    pull: vi.fn().mockResolvedValue({ treeChanged: true }),
     diffStat: vi.fn(),
     pendingChanges: vi.fn(),
     resolveForkBase: vi.fn(),
@@ -559,7 +559,7 @@ describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest'
 
   function makeRevertGit(overrides: Record<string, unknown> = {}): GitService {
     return Object.assign(makeGit(), {
-      pull: vi.fn().mockResolvedValue(undefined),
+      pull: vi.fn().mockResolvedValue({ treeChanged: true }),
       changedPathsForPr: vi.fn().mockResolvedValue(['Docs/a.md', 'Docs/b.md']),
       mergeBaseForPr: vi.fn().mockResolvedValue('mb-sha'),
       restorePathFromRef: vi.fn().mockResolvedValue(undefined),

package/src/modules/workflow/__tests__/workflow.service.releaseLock.test.ts

@@ -8,9 +8,10 @@ import type { IAccessControl } from '../../access/access-control.interface.js';
 import { FileLockService } from '../file-lock.service.js';
 import { PendingCommitsService } from '../pending-commits.service.js';
 import { WorkflowEventBus } from '../event-bus.js';
-import { WorkflowService } from '../workflow.service.js';
+import { WorkflowService, syncConflictMessage } from '../workflow.service.js';
 import type { Database } from '../../database/connection.js';
 import {
+  PullRebaseConflictError,
   PullRebaseConflictError,
   PushNeedsAgentResolutionError,
   WorkflowValidationError,
@@ -87,7 +88,7 @@ function makePending(): PendingCommitsService {
 function makeGit(overrides: Partial<{
   commitFile: Change | null;
   pushBehavior: 'ok' | 'nff' | 'auth-fail';
-  pullBehavior: 'ok' | 'fail';
+  pullBehavior: 'ok' | 'fail' | 'conflict';
   pushAfterPullBehavior: 'ok' | 'fail';
   hasUnpushedCommits: boolean;
 }> = {}): GitService {
@@ -120,6 +121,8 @@ function makeGit(overrides: Partial<{
     }),
     pull: vi.fn().mockImplementation(async () => {
       if (pullBehavior === 'fail') throw new Error('git pull failed: merge conflict');
+      if (pullBehavior === 'conflict') throw new PullRebaseConflictError('feat/x', ['foo.md'], 'CONFLICT (content)');
+      return { treeChanged: true };
     }),
   } as unknown as GitService;
 }
@@ -460,6 +463,29 @@ describe('WorkflowService.runPendingCommit — worker entry point', () => {
     ]);
   });
 
+  it('a rebase CONFLICT on the recovery path raises the banner WITH its files, like the remote sync does', async () => {
+    // The banner keeps the latest failure per branch. The remote sync raises
+    // the conflict variant (files as links); if this path then raised the
+    // generic variant for the same conflict, the retry would take the links
+    // away — seen on staging. Every path names the files.
+    const git = makeGit({
+      commitFile: null,
+      hasUnpushedCommits: true,
+      pushBehavior: 'nff',
+      pullBehavior: 'conflict',
+    });
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
+    await expect(svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER)).rejects.toBeInstanceOf(
+      PushNeedsAgentResolutionError,
+    );
+    const failed = emitSpy.mock.calls.map((c) => c[0] as Record<string, unknown>).find((e) => e.kind === 'git-sync-failed');
+    expect(failed).toMatchObject({
+      branch: 'feat/x',
+      conflictedPaths: ['foo.md'],
+      reason: syncConflictMessage('feat/x', ['foo.md']),
+    });
+  });
+
   it('recovers from non-fast-forward push via pull --rebase + retry, emits file-changed exactly once', async () => {
     // Teammate pushed to the same branch between our commit and our
     // push. The cooperative path pulls + retries — this is the case
@@ -750,3 +776,94 @@ describe('WorkflowService.updateFromRemote — pull-conflict recovery dispatch',
     await expect(svc.updateFromRemote('main', USER)).rejects.toBe(CONFLICT);
   });
 });
+
+describe('WorkflowService.updateFromRemote — the tree-change announcement', () => {
+  /**
+   * The announcement under test is what keeps the DEFAULT branch's catalog
+   * caches (skills, tool manuals, plugin index) honest: a pull is the one way
+   * a tree changes without passing the write routes, so `pullWorkspace` owes
+   * the process an `fs-tree-changed` — and owes it ONLY when the pull moved
+   * HEAD, on the default branch, after the pull resolved. Asserted through
+   * `updateFromRemote`, the public verb that wraps `pullWorkspace`.
+   */
+  const DEFAULT_WS = 'target-company-state'; // == the test env's DEFAULT_BRANCH
+
+  function makePullingGit(result: { treeChanged: boolean } | Error): {
+    git: GitService;
+    pullSettled: () => boolean;
+  } {
+    let settled = false;
+    const git = {
+      pull: vi.fn().mockImplementation(async () => {
+        // A microtask gap, so an emit issued before the await would be
+        // observably premature rather than coincidentally ordered.
+        await Promise.resolve();
+        settled = true;
+        if (result instanceof Error) throw result;
+        return result;
+      }),
+    } as unknown as GitService;
+    return { git, pullSettled: () => settled };
+  }
+
+  function treeChangedEvents(emitSpy: MockInstance): unknown[] {
+    return emitSpy.mock.calls
+      .map((c) => c[0] as { kind: string })
+      .filter((e) => e.kind === 'fs-tree-changed');
+  }
+
+  it('emits fs-tree-changed for the default workspace once the pull has changed the tree', async () => {
+    const events = new WorkflowEventBus();
+    const emitSpy = vi.spyOn(events, 'emit');
+    const { git, pullSettled } = makePullingGit({ treeChanged: true });
+    let settledAtEmit: boolean | undefined;
+    emitSpy.mockImplementation(() => {
+      settledAtEmit = pullSettled();
+    });
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
+
+    await svc.updateFromRemote(DEFAULT_WS, USER);
+
+    expect(treeChangedEvents(emitSpy)).toEqual([
+      { kind: 'fs-tree-changed', workspaceId: DEFAULT_WS, branch: DEFAULT_WS },
+    ]);
+    // After the pull RESOLVED — an emit for a pull that later failed would
+    // make other clients refetch a tree that never changed.
+    expect(settledAtEmit).toBe(true);
+  });
+
+  it('stays silent when the pull found nothing new (treeChanged: false)', async () => {
+    const events = new WorkflowEventBus();
+    const emitSpy = vi.spyOn(events, 'emit');
+    const { git } = makePullingGit({ treeChanged: false });
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
+
+    await svc.updateFromRemote(DEFAULT_WS, USER);
+
+    // An "already up to date" sync must not drop the catalogs or make every
+    // attached browser refetch its file tree.
+    expect(treeChangedEvents(emitSpy)).toEqual([]);
+  });
+
+  it('stays silent for a non-default workspace even when the tree changed', async () => {
+    const events = new WorkflowEventBus();
+    const emitSpy = vi.spyOn(events, 'emit');
+    const { git } = makePullingGit({ treeChanged: true });
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
+
+    await svc.updateFromRemote(encodeURIComponent('alice/draft'), USER);
+
+    expect(treeChangedEvents(emitSpy)).toEqual([]);
+  });
+
+  it('stays silent when the pull throws', async () => {
+    const events = new WorkflowEventBus();
+    const emitSpy = vi.spyOn(events, 'emit');
+    const { git } = makePullingGit(new Error('git fetch failed: could not resolve host'));
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
+
+    await expect(svc.updateFromRemote(DEFAULT_WS, USER)).rejects.toThrow();
+
+    expect(treeChangedEvents(emitSpy)).toEqual([]);
+  });
+});