@bevel-software/platform-core-backend 0.32.0 → 0.34.0

package/src/modules/workspace/__tests__/workspace.routes.read-gate.test.ts

@@ -47,7 +47,7 @@ interface Harness {
 async function makeHarness(opts: {
   kbFiles?: Record<string, string>;
   allowFn?: (p: string) => boolean;
-  /** Whether the caller is an admin — only `.bevelignore`'s visibility uses it. */
+  /** Whether the caller is an admin. The tree filter no longer reads it; the routes still take the service. */
   isAdmin?: boolean;
 } = {}): Promise<Harness> {
   const allowP = opts.allowFn ?? allow;
@@ -302,55 +302,35 @@ describe('read-permission gates on human read routes', () => {
 });
 
 /**
- * `.bevelignore` decides what the file tree and the agent view show at all, so
- * it is deployment configuration rather than knowledge. It also sits alone in
- * being visible — its siblings (`.gitignore`, `roles.yaml`, `access.md`,
- * `AGENTS.md`) are hidden from every reader by the shipped ignore rules.
- *
- * READ PERMISSION IS NOT THE LEVER, which is why this is a listing decision and
- * not an ACL one: everyone can read the file (it has to be readable to be
- * applied), so the tests below hold the read verdict at `true` throughout and
- * assert that admin-ness alone moves the outcome.
+ * `.bevelignore` is listed for whoever may read it, like any other file. It
+ * used to be admins only — a listing decision, since every reader can open it
+ * (it has to be readable to be applied) — until Razvan reversed that on
+ * 2026-10-23: being an admin moves nothing; the read verdict alone does.
  */
-describe('.bevelignore is admin-only in the file tree', () => {
+describe('.bevelignore is listed for whoever may read it', () => {
   let h: Harness | null = null;
   afterEach(async () => { if (h) await close(h.server); h = null; });
 
-  // The harness's default `allow` — none of the paths below contain "Secret",
-  // so every one of them is READABLE. That is the point: the read verdict is
-  // held constant and admin-ness alone moves the outcome.
-  const treeFilter = async (isAdmin: boolean) => {
-    h = await makeHarness({ isAdmin });
+  const treeFilter = async (opts: Parameters<typeof makeHarness>[0] = {}) => {
+    h = await makeHarness(opts);
     await fetch(`${h.baseUrl}/api/workspace/${WS}/files`);
     return h.listFilesFilter()!;
   };
 
-  it('hides it from a non-admin who can otherwise read everything', async () => {
-    const verdict = await (await treeFilter(false))([
+  it('shows the repository root file, and a nested one, to a non-admin who may read them', async () => {
+    const verdict = await (await treeFilter({ isAdmin: false }))([
       `${KB}/.bevelignore`,
+      `${KB}/KnowledgeBase/Product/.bevelignore`,
       `${KB}/Knowledge/Open/a.md`,
     ]);
-    // Unlisted, not denied: hiding it withholds no content, so it never
-    // counts toward the tree's `withheld`.
-    expect(verdict.get(`${KB}/.bevelignore`)).toBe('unlisted');
-    // Only that one file — the rest of the tree is untouched.
-    expect(verdict.get(`${KB}/Knowledge/Open/a.md`)).toBe(true);
-  });
-
-  it('shows it to an admin', async () => {
-    const verdict = await (await treeFilter(true))([`${KB}/.bevelignore`]);
     expect(verdict.get(`${KB}/.bevelignore`)).toBe(true);
+    expect(verdict.get(`${KB}/KnowledgeBase/Product/.bevelignore`)).toBe(true);
+    expect(verdict.get(`${KB}/Knowledge/Open/a.md`)).toBe(true);
   });
 
-  /** The stack is hierarchical — a nested one governs its own subtree. */
-  it('hides a nested one too, not just the repo-root file', async () => {
-    const verdict = await (await treeFilter(false))([`${KB}/KnowledgeBase/Product/.bevelignore`]);
-    expect(verdict.get(`${KB}/KnowledgeBase/Product/.bevelignore`)).toBe('unlisted');
-  });
-
-  /** Basename match, not substring: a file merely NAMED after it stays visible. */
-  it('does not hide files whose name only contains it', async () => {
-    const verdict = await (await treeFilter(false))([`${KB}/Knowledge/.bevelignore.md`]);
-    expect(verdict.get(`${KB}/Knowledge/.bevelignore.md`)).toBe(true);
+  it('hides it, counted as withheld like any file, from a reader the read rules refuse', async () => {
+    // The harness's `allow` refuses every path under "Secret".
+    const verdict = await (await treeFilter({ isAdmin: true }))([`${KB}/Knowledge/Secret/.bevelignore`]);
+    expect(verdict.get(`${KB}/Knowledge/Secret/.bevelignore`)).toBe(false);
   });
 });

package/src/modules/workspace/__tests__/workspace.service.ensure-remotes-fetched.test.ts

@@ -106,4 +106,34 @@ describe('WorkspaceService.ensureRemotesFetched', () => {
 
     expect(fetches().length - beforeTheRace).toBe(1);
   });
+
+  // What an AUTHORIZING caller (`changeRequestDecisionGrant`) relies on: a
+  // warm cache must not stand in for a refresh that failed. `strict` alone
+  // answers from the window without fetching, so only `strict + force` turns
+  // an origin outage into a refusal instead of a check against older refs.
+  it('strict + force refuses when the refresh fails, even with a warm cache', async () => {
+    let failing = false;
+    runner = {
+      defaultTimeoutMs: 1000,
+      run: vi.fn(async (_cwd: string, args: string[]) => {
+        runs.push(args);
+        if (failing && args[0] === 'fetch') throw new Error('origin unreachable');
+        return { stdout: '', stderr: '' };
+      }),
+      // Read by the failure log, which redacts the token from the error.
+      credentials: { token: () => null },
+    } as unknown as IGitRunner;
+    const svc = service();
+    await svc.ensureRemotesFetched('main', { strict: true }); // warms the window
+    failing = true;
+
+    // Inside the window, strict alone does not even try the remote.
+    await expect(svc.ensureRemotesFetched('main', { strict: true })).resolves.toBeUndefined();
+    expect(fetches()).toHaveLength(1);
+
+    await expect(svc.ensureRemotesFetched('main', { strict: true, force: true })).rejects.toThrow(
+      /could not be refreshed/,
+    );
+    expect(fetches()).toHaveLength(2);
+  });
 });

package/src/modules/workspace/__tests__/workspace.service.read-filter.test.ts

@@ -177,14 +177,6 @@ describe('WorkspaceService.listFiles — read filter', () => {
       expect(tree.withheld).toBe(1);
     });
 
-    it('does not count an entry the filter marks unlisted', async () => {
-      const filter: ReadTreeFilter = async (ps) =>
-        new Map(ps.map((p) => [p, p === 'top.md' ? 'unlisted' : true]));
-      const tree = await svc.listFiles(workspaceId, filter);
-      expect(paths(tree)).not.toContain('top.md');
-      expect(tree.withheld).toBeUndefined();
-    });
-
     it('counts every entry of a tree the caller may read none of', async () => {
       const filter: ReadTreeFilter = async () => new Map();
       const tree = await svc.listFiles(workspaceId, filter);
@@ -192,6 +184,26 @@ describe('WorkspaceService.listFiles — read filter', () => {
       // Every entry below the root, exactly — the root itself is never withheld.
       expect(tree.withheld).toBe(paths(await svc.listFiles(workspaceId)).length - 1);
     });
+
+    /**
+     * `.bevelignore` is a file like any other to the tree: listed where the
+     * caller may read it, counted as withheld where they may not. It used to
+     * be marked `'unlisted'` for non-admins — hidden and uncounted — until
+     * that listing decision was reversed on 2026-10-23.
+     */
+    it('lists a readable .bevelignore and counts a denied one as withheld, like any file', async () => {
+      await mkFile(workspaceDir, '.bevelignore', '');
+      await mkFile(workspaceDir, 'Mixed/.bevelignore', '');
+      // A reader kept out of Mixed/ is kept out of its ignore file too.
+      const filter: ReadTreeFilter = async (ps) => new Map(ps.map((p) => [p, !p.startsWith('Mixed/')]));
+      const tree = await svc.listFiles(workspaceId, filter);
+      expect(paths(tree)).toContain('.bevelignore');
+      expect(paths(tree)).not.toContain('Mixed/.bevelignore');
+      const mixed = tree.children!.find((c) => c.relativePath === 'Mixed');
+      // hidden.md and .bevelignore: two files kept out, both counted.
+      expect(mixed?.withheld).toBe(2);
+      expect(tree.withheld).toBe(2);
+    });
   });
 
   it('fails closed: a path not marked readable is dropped', async () => {

package/src/modules/workspace/__tests__/workspace.tools.agents-file.test.ts

@@ -10,16 +10,17 @@ import { createToolHandlerFactory } from '../../tool-helpers/tool-handler.js';
 import type { ToolAuth } from '../../tool-auth/tool-auth.middleware.js';
 import type { IAccessControl } from '../../access/access-control.interface.js';
 import { DocExtractService } from '../file-readers/doc-extract.service.js';
+import { WorkerDocumentExtractor } from '../file-readers/extract-in-worker.js';
 import { RoutineWritePolicyService } from '../routine-write-policy.js';
 import { SpillStore } from '../spill-store.js';
 import { WorkflowHooks } from '../../workflow/workflow-hooks.js';
 import { ToolDescriptionNotes } from '../../workspace/agent-access.gate.js';
 import { registerWorkspaceTools } from '../workspace.tools.js';
 import { sharedFileRulesSection } from '../../agent-instructions/shared-file-rules.js';
-import { WorkerPatternMatcher } from '../bounded-matcher.js';
+import { RipgrepPatternMatcher } from '../index.js';
 
 /** The grep matcher this file's harness wires, closed once the file is done. */
-const patternMatcher = new WorkerPatternMatcher();
+const patternMatcher = new RipgrepPatternMatcher();
 afterAll(() => patternMatcher.close());
 
 /**
@@ -47,7 +48,7 @@ async function descriptions(registry: ToolRegistry = new ToolRegistry()): Promis
     auth,
     createToolHandlerFactory(() => ({ userEmail: 'a@x.io' })) as never,
     new SpillStore(join(tmpdir(), 'bevel-test-spills')),
-    new DocExtractService(join(tmpdir(), 'bevel-test-doc-extract')),
+    new DocExtractService(join(tmpdir(), 'bevel-test-doc-extract'), new WorkerDocumentExtractor()),
     {} as unknown as IAccessControl,
     kb,
     {

package/src/modules/workspace/__tests__/workspace.tools.branch-errors.test.ts

@@ -26,8 +26,10 @@ import { ToolDescriptionNotes } from '../../workspace/agent-access.gate.js';
 import { RoutineWritePolicyService } from '../routine-write-policy.js';
 import { SpillStore } from '../spill-store.js';
 import { DocExtractService } from '../file-readers/doc-extract.service.js';
+import { WorkerDocumentExtractor } from '../file-readers/extract-in-worker.js';
 import { registerWorkspaceTools } from '../workspace.tools.js';
-import { WorkerPatternMatcher } from '../bounded-matcher.js';
+import { RipgrepPatternMatcher } from '../index.js';
+import { slowRipgrep } from '../../../__tests__/slow-ripgrep.js';
 import { WorkspaceService } from '../workspace.service.js';
 import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
@@ -71,7 +73,7 @@ describe('workspace tools — a branch that cannot be opened', () => {
   let workspaces: WorkspaceService | null = null;
   let spillRoot = '';
   let docCacheDir = '';
-  let patternMatcher: WorkerPatternMatcher | undefined;
+  let patternMatcher: RipgrepPatternMatcher | undefined;
 
   afterEach(async () => {
     if (httpServer) {
@@ -189,7 +191,7 @@ describe('workspace tools — a branch that cannot be opened', () => {
         isMissing: (branch) => workspaces!.isBranchMissing(branch),
       }),
       new SpillStore(spillRoot),
-      new DocExtractService(docCacheDir),
+      new DocExtractService(docCacheDir, new WorkerDocumentExtractor()),
       allowAll,
       testKbContext({ kbDirName: KB_DIR }),
       {
@@ -207,7 +209,7 @@ describe('workspace tools — a branch that cannot be opened', () => {
       undefined,
       undefined,
       undefined,
-      (patternMatcher = new WorkerPatternMatcher()),
+      (patternMatcher = new RipgrepPatternMatcher()),
     );
     app.use('/api', router);
     internalTools = (await registry.listInternal()) as unknown as { name: string; inputs: unknown }[];
@@ -494,12 +496,15 @@ describe('workspace tools — a branch that cannot be opened', () => {
   /**
    * Not about branches, but this file holds the real chain harness: a grep
    * called from inside `call_tool_chain` reaches the same route, so the same
-   * bound stops a catastrophic pattern there — the chain answers the worded
-   * 400 rather than waiting out its own timeout on a held event loop.
+   * bound stops a search there that would not finish — the chain answers the
+   * worded 400 rather than waiting out its own timeout. The walk that never
+   * finishes is a ripgrep that sleeps (`slowRipgrep`); a single file's text
+   * still goes to the real one.
    */
-  it('stops a too-expensive grep pattern from inside call_tool_chain, and a control pattern still matches', async () => {
+  it('stops a too-expensive grep from inside call_tool_chain, and a control search still matches', async () => {
     const line = `${'a'.repeat(39)}!`;
     const base = await start({ files: { 'redos.md': `${line}\n` } });
+    const slow = await slowRipgrep();
     const client = await CodeModeUtcpClient.create(process.cwd(), {
       variables: { bevel_API_URL: base, bevel_CONNECTION_KEY: 'internal-token' },
     } as never);
@@ -515,12 +520,12 @@ describe('workspace tools — a branch that cannot be opened', () => {
         }),
       );
       const { result } = await client.callToolChain(
-        `const grep = (pattern) => bevel.grep({ body: { branch: 'alice/draft', pattern, path: 'knowledge-base/redos.md' } });
+        `const grep = (pattern, path) => bevel.grep({ body: { branch: 'alice/draft', pattern, path } });
          let expensive;
          const started = Date.now();
-         try { expensive = { ok: grep('^(a+)+$') }; } catch (err) { expensive = { failed: err.message }; }
+         try { expensive = { ok: grep('^a+!$', 'knowledge-base') }; } catch (err) { expensive = { failed: err.message }; }
          const took = Date.now() - started;
-         return { expensive, took, control: grep('^a+!$') };`,
+         return { expensive, took };`,
         30_000,
       );
       // The search is stopped at the ticket's 5 s budget: timed around the call
@@ -530,9 +535,17 @@ describe('workspace tools — a branch that cannot be opened', () => {
       expect(result.expensive.ok).toBeUndefined();
       expect(result.expensive.failed).toContain('HTTP 400');
       expect(result.expensive.failed).toContain('Pattern too expensive');
-      expect(result.control.matches).toEqual([{ path: `${KB_DIR}/redos.md`, line: 1, text: line }]);
+      expect(await slow.alive()).toEqual([]);
+      // With the real ripgrep back, the same pattern matches the line.
+      await slow.remove();
+      const { result: control } = await client.callToolChain(
+        `return bevel.grep({ body: { branch: 'alice/draft', pattern: '^a+!$', path: 'knowledge-base/redos.md' } });`,
+        30_000,
+      );
+      expect(control.matches).toEqual([{ path: `${KB_DIR}/redos.md`, line: 1, text: line }]);
     } finally {
       await client.close();
+      await slow.remove();
     }
   });