@bevel-software/platform-core-backend 0.20.0 → 0.21.0

package/src/modules/plugins/discovery/kb-plugin-source.ts

@@ -1,7 +1,8 @@
 import path from 'node:path';
-import { PLUGINS_DIR, PLUGIN_MANIFEST_FILE, pluginManifestName } from '@bevel-software/platform-shared';
+import { PLUGIN_MANIFEST_FILE, pluginManifestName, type KbLayout } from '@bevel-software/platform-shared';
 import type { DiscoveredPlugin, Discovery, PluginSource, PluginSourceWalk } from './plugin-source.js';
 import type { IFsProbe, ITreeWalker, WalkListener } from '../../../shared/fs.contract.js';
+import type { KbContext } from '../../../shared/kb-context.js';
 import { readNativePlugin } from './native.source.js';
 import { BUNDLE_FILE, loadRegistry, readBundlePlugin } from './bundle-dialect/bundle.source.js';
 import type { McpRegistry } from './bundle-dialect/registry.js';
@@ -38,7 +39,11 @@ import type { McpRegistry } from './bundle-dialect/registry.js';
 export class KbPluginSource implements PluginSource {
   readonly dialect = 'kb';
 
-  constructor(private readonly disk: ITreeWalker & IFsProbe) {}
+  constructor(
+    private readonly disk: ITreeWalker & IFsProbe,
+    /** Read per walk, never captured: the plugins root is renameable from the setup screen. */
+    private readonly kb: Pick<KbContext, 'layout'>,
+  ) {}
 
   async discover(kbRoot: string): Promise<Discovery> {
     return (await this.walkWith(kbRoot, [])).discovery;
@@ -47,7 +52,7 @@ export class KbPluginSource implements PluginSource {
   async walkWith(kbRoot: string, listeners: readonly WalkListener[]): Promise<PluginSourceWalk> {
     const warnings: string[] = [];
     const registry = await loadRegistry(kbRoot, warnings);
-    const listener = pluginListener(this.disk, kbRoot, registry, warnings);
+    const listener = pluginListener(this.disk, kbRoot, this.kb.layout, registry, warnings);
     const { holes } = await this.disk.walkKb(kbRoot, [listener.listener, ...listeners]);
     return { discovery: listener.result(), holes };
   }
@@ -57,16 +62,18 @@ export class KbPluginSource implements PluginSource {
 function pluginListener(
   disk: IFsProbe,
   kbRoot: string,
+  layout: KbLayout,
   registry: McpRegistry | null,
   warnings: string[],
 ): { listener: WalkListener; result(): Discovery } {
+  const { pluginsDir } = layout;
   const unreadable: string[] = [];
   const plugins: DiscoveredPlugin[] = [];
   const seen = new Map<string, string>();
   /** Folders claimed as plugins (or as holes standing where a plugin may be): nothing beneath is looked at. */
   const claimed: string[] = [];
 
-  const underRoot = (rel: string) => rel === PLUGINS_DIR || rel.startsWith(`${PLUGINS_DIR}/`);
+  const underRoot = (rel: string) => rel === pluginsDir || rel.startsWith(`${pluginsDir}/`);
   const beneathClaimed = (rel: string) => claimed.some((c) => rel === c || rel.startsWith(`${c}/`));
 
   // Uniqueness is judged on the MANIFEST SLUG, not the raw name: `Sales Team`
@@ -87,18 +94,18 @@ function pluginListener(
   return {
     listener: {
       async onDir(rel, entries) {
-        if (!underRoot(rel) || rel === PLUGINS_DIR || beneathClaimed(rel)) return;
+        if (!underRoot(rel) || rel === pluginsDir || beneathClaimed(rel)) return;
         const has = (name: string) => entries.some((e) => e.isFile() && e.name === name);
         const dir = path.join(kbRoot, rel);
-        const relFolder = rel.slice(PLUGINS_DIR.length + 1);
+        const relFolder = rel.slice(pluginsDir.length + 1);
         if (has(PLUGIN_MANIFEST_FILE)) {
           claimed.push(rel);
           // A manifest that could not be read: a hole, and still claimed.
-          const native = await readNativePlugin(disk, dir, rel, relFolder, warnings, unreadable);
+          const native = await readNativePlugin(disk, dir, rel, relFolder, warnings, unreadable, layout);
           if (native) claim(native);
         } else if (has(BUNDLE_FILE)) {
           claimed.push(rel);
-          const bundle = await readBundlePlugin(dir, rel, relFolder, registry, warnings, unreadable);
+          const bundle = await readBundlePlugin(dir, rel, relFolder, registry, warnings, unreadable, layout);
           if (bundle) claim(bundle);
         }
       },

package/src/modules/plugins/discovery/native.source.ts

@@ -8,6 +8,7 @@ import {
   linkedSkillRoots,
   pluginDisplayNameOf,
   pluginIdentityOf,
+  type KbLayout,
 } from '@bevel-software/platform-shared';
 import { isAbsence, type IFsProbe } from '../../../shared/fs.contract.js';
 import type { DiscoveredPlugin } from './plugin-source.js';
@@ -31,6 +32,8 @@ export async function readNativePlugin(
   relFolder: string,
   warnings: string[],
   unreadable: string[],
+  /** Names the plugins root a personal folder sits directly under. */
+  layout: KbLayout,
 ): Promise<DiscoveredPlugin | null> {
   const folderName = path.posix.basename(relFolder);
   const manifestRead = await readText(path.join(dir, PLUGIN_MANIFEST_FILE), folder, warnings);
@@ -97,7 +100,7 @@ export async function readNativePlugin(
     folder,
     relFolder,
     // The one structural rule: a direct child of the root with the prefix.
-    personal: isPersonalPluginDir(folder),
+    personal: isPersonalPluginDir(folder, layout),
     exists,
     manifest,
     manifestText,

package/src/modules/plugins/index.ts

@@ -1,4 +1,4 @@
-export { PluginIndexService, pluginsWorkspaceId, pluginFolderBelowRoot } from './plugins.service.js';
+export { PluginIndexService, pluginFolderBelowRoot } from './plugins.service.js';
 export {
   PluginProvisionService,
   PluginProvisionError,

package/src/modules/plugins/join-request-jobs.service.ts

@@ -1,5 +1,4 @@
 import {
-  DEFAULT_BRANCH,
   joinBranchFor,
   type AuthUser,
   type ChangeRequestState,
@@ -9,8 +8,8 @@ import { spliceGrant } from '../access-model/access-splice.js';
 import { sanitizeError } from '../workflow/sanitize-error.js';
 import { logger } from '../../shared/logging.js';
 import { printable } from '../../shared/printable.js';
+import type { KbContext } from '../../shared/kb-context.js';
 import type { WorkspaceService } from '../workspace/workspace.service.js';
-import { pluginsWorkspaceId } from './plugins.service.js';
 import type {
   ClaimedJoinRequest,
   JoinRequestRecord,
@@ -148,7 +147,8 @@ export interface JoinRequestJobsDeps {
     | 'listChangeRequestsAuthoredBy'
   >;
   workspaceService: Pick<WorkspaceService, 'getOrCreateForBranch' | 'readFile' | 'writeFile'>;
-  kbDirName: string;
+  /** The checkout folder, and which branch the request is cut from and aimed at. */
+  kb: Pick<KbContext, 'kbDirName' | 'defaultBranch' | 'defaultWorkspaceId'>;
   /**
    * The plugin a recorded key still names, or null when nothing does — it was
    * deleted, or its folder moved out from under the record.
@@ -508,7 +508,8 @@ export class PluginJoinRequestJobs {
     claim: ClaimedJoinRequest,
     stillOurs: () => Promise<void>,
   ): Promise<void> {
-    const { workflow, workspaceService, kbDirName } = this.deps;
+    const { workflow, workspaceService, kb } = this.deps;
+    const { kbDirName } = kb;
     const target = await this.deps.target(record.pluginKey);
     if (!target) throw new Error('the plugin is no longer available');
     const user = await this.deps.requester(record.requesterEmail);
@@ -607,7 +608,7 @@ export class PluginJoinRequestJobs {
     }
     const detail = await workflow.openChangeRequest(ws.id, user, {
       sourceBranch: branch,
-      targetBranch: DEFAULT_BRANCH,
+      targetBranch: kb.defaultBranch,
       // People read these: the display name, not the identifier.
       title: `Join request: ${target.displayName}`,
       description:
@@ -637,9 +638,9 @@ export class PluginJoinRequestJobs {
    * leaves the next click free to retry the same row.
    */
   private async ensureBranch(branch: string): Promise<void> {
-    const wsId = pluginsWorkspaceId();
+    const wsId = this.deps.kb.defaultWorkspaceId();
     try {
-      await this.deps.workflow.createBranch(wsId, branch, DEFAULT_BRANCH);
+      await this.deps.workflow.createBranch(wsId, branch, this.deps.kb.defaultBranch);
       return;
     } catch (err) {
       const branches = await this.deps.workflow.listBranches(wsId, {

package/src/modules/plugins/join-requests.service.ts

@@ -1,5 +1,4 @@
 import {
-  DEFAULT_BRANCH,
   isJoinBranchFor,
   type AuthUser,
   type ChangeRequest,
@@ -9,7 +8,7 @@ import { type WorkspaceService } from '../workspace/workspace.service.js';
 import { logger } from '../../shared/logging.js';
 
 const log = logger('plugins');
-import { workspaceIdForBranch } from '../../shared/workspace-id.js';
+import type { KbContext } from '../../shared/kb-context.js';
 import { pendingProposals, type JoinProposal } from './join-proposals.js';
 
 /** One open join change request, with what it still proposes. */
@@ -46,6 +45,7 @@ export class JoinRequestsService {
   constructor(
     private readonly workspaceService: WorkspaceService,
     private readonly workflow: IWorkflowService,
+    private readonly kb: Pick<KbContext, 'defaultBranch' | 'defaultWorkspaceId'>,
   ) {}
 
   /**
@@ -64,7 +64,7 @@ export class JoinRequestsService {
   ): Promise<JoinRequest[]> {
     await this.refresh();
     const accessPath = `${folder}/access.md`;
-    const baseText = await this.readAt(DEFAULT_BRANCH, accessPath);
+    const baseText = await this.readAt(this.kb.defaultBranch, accessPath);
     const out: JoinRequest[] = [];
     for (const cr of crs) {
       if (cr.state !== 'open' || !isJoinBranchFor(cr.branch, plugin)) continue;
@@ -104,7 +104,7 @@ export class JoinRequestsService {
     const accessPath = `${folder}/access.md`;
     const proposals = pendingProposals(
       await this.readAt(cr.branch, accessPath),
-      await this.readAt(DEFAULT_BRANCH, accessPath),
+      await this.readAt(this.kb.defaultBranch, accessPath),
       accessPath,
     );
     if (proposals.length > 0) return false;
@@ -125,7 +125,7 @@ export class JoinRequestsService {
    * next pass tries again.
    */
   private async settle(cr: ChangeRequest, actor: AuthUser): Promise<void> {
-    const wsId = workspaceIdForBranch(DEFAULT_BRANCH);
+    const wsId = this.kb.defaultWorkspaceId();
     try {
       await this.workflow.rejectChangeRequest(
         cr.number,
@@ -167,7 +167,7 @@ export class JoinRequestsService {
   private async readAt(branch: string, repoRelPath: string): Promise<string | null> {
     try {
       return await this.workspaceService.readFileAtRef(
-        workspaceIdForBranch(DEFAULT_BRANCH),
+        this.kb.defaultWorkspaceId(),
         `origin/${branch}`,
         repoRelPath,
       );
@@ -183,7 +183,7 @@ export class JoinRequestsService {
    */
   private async refresh(): Promise<void> {
     await this.workspaceService
-      .ensureRemotesFetched(workspaceIdForBranch(DEFAULT_BRANCH))
+      .ensureRemotesFetched(this.kb.defaultWorkspaceId())
       .catch(() => undefined);
   }
 }

package/src/modules/plugins/plugin-links.service.ts

@@ -1,7 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import {
-  DEFAULT_BRANCH,
   PLUGIN_MANIFEST_FILE,
   linkedSkillRoots,
   normalizeSkillRoot,
@@ -19,8 +18,57 @@ import { pluginPrincipalKey } from '../access-model/access-grammar.js';
 import type { Principal } from '../access-model/access-splice.js';
 import { WorkspaceMutex } from '../kb-fs/mutex.js';
 import type { ISkillService } from '../skills/skills.contract.js';
+import { logger } from '../../shared/logging.js';
 import type { ProvisionCommitDriver } from './plugin-provision.service.js';
-import { linksWorkspaceId, type PluginLinkIndex } from './plugin-links.js';
+import type { PluginLinkIndex } from './plugin-links.js';
+import type { KbContext } from '../../shared/kb-context.js';
+
+const log = logger('plugins');
+
+/** Who may edit one skill root's access file, in the terms the banner names them. */
+export interface LinkEditors {
+  roles: string[];
+  users: { name: string; email: string }[];
+}
+
+/** One link the automatic repair left alone, and why — see `repairAll`. */
+export interface UnrepairedLink {
+  /** Repo-relative root, as the manifest declares it. */
+  root: string;
+  /**
+   * `needs-skill-write` — the viewer may not write the root's access file, so
+   * nothing was attempted; `failed` — the write was attempted and did not
+   * land; `denied` — both lines are already in the file and the link is still
+   * not granted, which is a `deny` of the plugin at that root: nothing to
+   * write, and only an editor removing the deny would change it. All three
+   * leave the link broken and all three keep the banner.
+   */
+  reason: 'needs-skill-write' | 'failed' | 'denied';
+  /** The skills the plugin's members still cannot read through the root. */
+  skills: { path: string; name: string }[];
+  /** Who can repair it from the skill page. */
+  editors: LinkEditors;
+}
+
+/** What one page-open repair did and what it could not do. */
+export interface LinkRepairReport {
+  /** Roots whose two grant lines are now in place (silent: nothing to show). */
+  repaired: string[];
+  /** What is still broken, and who can fix it. */
+  skipped: UnrepairedLink[];
+}
+
+/**
+ * The commit subject for an automatic repair. It names the plugin, the root
+ * and the fact that nobody asked for it — the commit is the ONLY trace a
+ * silent repair leaves, so the history has to explain itself. Falls back to
+ * the path-derived default when a very long root would blow the 200-character
+ * subject limit: a missed explanation is not worth a failed repair.
+ */
+function repairSummary(plugin: string, root: string): string | undefined {
+  const subject = `Repair link: ${plugin} → ${root} (automatic, on opening the plugin page)`;
+  return subject.length <= 200 ? subject : undefined;
+}
 
 /** A refusal the route passes through: message + HTTP status + a machine-readable kind. */
 export class PluginLinkError extends Error {
@@ -59,7 +107,9 @@ export class PluginLinkError extends Error {
  * skill page says so, for a skill editor to remove.
  *
  * Repair re-grants the tokens for a link that exists but whose grant was
- * hand-removed: the amber dot's one action.
+ * hand-removed — the amber dot's one action, run one link at a time from the
+ * skill page, or over a whole plugin's links by `repairAll` the moment
+ * somebody who may write that plugin opens its page.
  *
  * Every operation is serialised on BOTH sides it writes — the plugin's
  * manifest slug (the same key provisioning locks on) and the skill root whose
@@ -77,19 +127,23 @@ export class PluginLinksService {
     private readonly accessControl: IAccessControl,
     private readonly skillService: ISkillService,
     private readonly links: PluginLinkIndex,
-    private readonly kbDirName: string,
+    private readonly kb: KbContext,
     private readonly events?: {
       emit(event: { kind: 'fs-tree-changed'; workspaceId: string; branch: string }): void;
     },
     private readonly onChanged?: () => void,
   ) {
-    this.mutation = new AccessMutationService(workspaceService, accessControl, kbDirName);
+    this.mutation = new AccessMutationService(workspaceService, accessControl, kb.kbDirName);
+  }
+
+  private get kbDirName(): string {
+    return this.kb.kbDirName;
   }
 
   async link(user: AuthUser, plugin: string, rawRoot: string): Promise<{ root: string; skills: string[] }> {
     const folder = await this.pluginFolder(plugin);
     const root = this.rootOrThrow(rawRoot);
-    const wsId = linksWorkspaceId();
+    const wsId = this.kb.defaultWorkspaceId();
     await this.requirePluginWrite(wsId, user, folder);
     const skills = await this.resolvedSkills(root);
     if (skills.length === 0) {
@@ -125,7 +179,7 @@ export class PluginLinksService {
           manifestRel,
           `${JSON.stringify(withLinkedSkillRoots(manifest, [...roots, root]), null, 2)}\n`,
         );
-        await this.commits.runPendingCommit(wsId, DEFAULT_BRANCH, manifestRel, user);
+        await this.commits.runPendingCommit(wsId, this.kb.defaultBranch, manifestRel, user);
       }
       await this.grantTokens(wsId, user, folder, root);
       this.changed(wsId);
@@ -136,7 +190,7 @@ export class PluginLinksService {
   async unlink(user: AuthUser, plugin: string, rawRoot: string): Promise<{ root: string; revoked: boolean }> {
     const folder = await this.pluginFolder(plugin);
     const root = this.rootOrThrow(rawRoot);
-    const wsId = linksWorkspaceId();
+    const wsId = this.kb.defaultWorkspaceId();
     await this.requirePluginWrite(wsId, user, folder);
     return this.locks.runAll(this.lockKeys(folder, root), async () => {
       const { manifest, manifestRel } = await this.readManifest(wsId, folder);
@@ -163,7 +217,7 @@ export class PluginLinksService {
         if (changed) {
           await this.commits.runPendingCommit(
             wsId,
-            DEFAULT_BRANCH,
+            this.kb.defaultBranch,
             `${this.kbDirName}/${accessMdPathForFolder(root)}`,
             user,
           );
@@ -175,16 +229,36 @@ export class PluginLinksService {
         manifestRel,
         `${JSON.stringify(withLinkedSkillRoots(manifest, roots.filter((r) => r !== root)), null, 2)}\n`,
       );
-      await this.commits.runPendingCommit(wsId, DEFAULT_BRANCH, manifestRel, user);
+      await this.commits.runPendingCommit(wsId, this.kb.defaultBranch, manifestRel, user);
       this.changed(wsId);
       return { root, revoked };
     });
   }
 
-  async repair(user: AuthUser, plugin: string, rawRoot: string): Promise<{ root: string }> {
+  /**
+   * Re-grant one link's two tokens. The skill EDITOR's verb (the plugin side
+   * is not consulted): the amber dot's one manual action, and the single
+   * write the automatic repair runs too — see {@link repairAll}.
+   *
+   * `summary` is the commit subject when the caller has a better one than the
+   * path-derived default; the automatic repair passes one that says it was
+   * automatic, because the commit is the only trace it leaves.
+   *
+   * `written` says whether the file changed. A root that already carried
+   * both lines is left alone and reports false — which, for a root the index
+   * called ungranted, means the lines are not what is missing (a `deny`
+   * beside them is): the automatic repair reads it as "still broken", not as
+   * repaired.
+   */
+  async repair(
+    user: AuthUser,
+    plugin: string,
+    rawRoot: string,
+    opts?: { summary?: string },
+  ): Promise<{ root: string; written: boolean }> {
     const folder = await this.pluginFolder(plugin);
     const root = this.rootOrThrow(rawRoot);
-    const wsId = linksWorkspaceId();
+    const wsId = this.kb.defaultWorkspaceId();
     // Everything under the lock, the manifest read included: a repair that
     // checked the link and then waited on an unlink would re-grant a root the
     // manifest no longer names.
@@ -199,14 +273,98 @@ export class PluginLinksService {
           root,
         });
       }
-      await this.grantTokens(wsId, user, folder, root);
+      const written = await this.grantTokens(wsId, user, folder, root, opts?.summary);
       this.changed(wsId);
-      return { root };
+      return { root, written };
     });
   }
 
+  /**
+   * Repair EVERY link of `plugin` that is missing its grants — what opening
+   * the plugin's page runs for someone who may write the plugin.
+   *
+   * Two gates, in this order: the caller must be able to write the PLUGIN
+   * (this is the plugin's page repairing its own links, not a way to write
+   * other people's access files), and then, per root, to write that root's
+   * access file. A root they cannot write is left exactly as it is and comes
+   * back in `skipped` with the people who CAN write it, which is the sentence
+   * the banner then says. Nothing comes back for a root that was repaired:
+   * the commit is the trace, the page simply renders with the link healthy.
+   *
+   * Root by root through {@link repair} — the same write, the same manifest
+   * check, the same pair of locks — so the automatic path and the button on
+   * the skill page can never write different things. Each root's failure is
+   * caught into `skipped`: one unwritable file must not cost the others their
+   * repair, nor the page its render.
+   *
+   * A root the repair did not have to write is NOT repaired. The work list
+   * holds only roots the index called ungranted, so a root whose two lines
+   * were already there is broken by something the lines cannot fix — a `deny`
+   * of the plugin in that same file — and reporting it repaired would hide
+   * the one link the writer opening this page could not see anywhere else.
+   */
+  async repairAll(user: AuthUser, plugin: string): Promise<LinkRepairReport> {
+    const folder = await this.pluginFolder(plugin);
+    const wsId = this.kb.defaultWorkspaceId();
+    await this.requirePluginWrite(wsId, user, folder);
+    // Read the work list ONCE, before the first write: `repair` invalidates
+    // the index, and re-reading it per root would rebuild the whole membership
+    // between every commit.
+    const work = (await this.links.membership()).byPlugin.get(folder)?.ungrantedRoots ?? [];
+    if (work.length === 0) return { repaired: [], skipped: [] };
+    const named = new Map((await this.skillService.listSkills(undefined)).map((s) => [s.path, s.name]));
+    const repaired: string[] = [];
+    const skipped: UnrepairedLink[] = [];
+    const leftBroken = async (item: (typeof work)[number], reason: UnrepairedLink['reason']) => {
+      skipped.push({
+        root: item.root,
+        reason,
+        skills: item.skills.map((path) => ({ path, name: named.get(path) ?? path.split('/').pop() ?? path })),
+        editors: await this.editorsOf(wsId, item.root),
+      });
+    };
+    for (const item of work) {
+      try {
+        const { written } = await this.repair(user, folder, item.root, { summary: repairSummary(folder, item.root) });
+        if (written) repaired.push(item.root);
+        else await leftBroken(item, 'denied');
+      } catch (err) {
+        const needsWrite = err instanceof PluginLinkError && err.payload.kind === 'needs-skill-write';
+        if (!needsWrite) log.warn('automatic link repair failed:', { plugin: folder, root: item.root, err });
+        await leftBroken(item, needsWrite ? 'needs-skill-write' : 'failed');
+      }
+    }
+    return { repaired, skipped };
+  }
+
   // --- internal --------------------------------------------------------------
 
+  /**
+   * Who may edit a root's access file — the principals the banner names as
+   * the people who can repair a link this viewer cannot.
+   *
+   * Plugin principals are dropped: `plugin/gtm/write` is a real holder of the
+   * verb, and naming it in a sentence addressed to a person says nothing they
+   * could act on. The eligible lists carry emails and no display names, so an
+   * email stands in — every name here has to be something a reader can go and
+   * ask. A lookup that fails names nobody rather than failing the whole
+   * repair — the banner has a sentence for that.
+   */
+  private async editorsOf(wsId: string, root: string): Promise<LinkEditors> {
+    try {
+      const writers = await this.accessControl.eligibleWriters(wsId, accessMdPathForFolder(root));
+      return {
+        roles: writers.principals
+          ? writers.principals.filter((p) => p.kind !== 'plugin').map((p) => p.name)
+          : writers.roles,
+        users: writers.users.map((u) => ({ name: u.name || u.email, email: u.email })),
+      };
+    } catch (err) {
+      log.warn("couldn't resolve a skill root's editors:", { root, err });
+      return { roles: [], users: [] };
+    }
+  }
+
   /**
    * ONE reservation for both sides of a link: the plugin's manifest AND the
    * skill root's access.md. Two plugins linking the same root write the same
@@ -232,13 +390,28 @@ export class PluginLinksService {
     ];
   }
 
-  private async grantTokens(wsId: string, user: AuthUser, folder: string, root: string): Promise<void> {
+  /**
+   * The two lines, and a commit only if they were not already there — the
+   * `changed` check is what makes re-linking, Repair and the page-open repair
+   * idempotent rather than a stream of empty commits. Returns whether the
+   * file changed, so a caller can tell a repair that wrote from one that had
+   * nothing to write.
+   */
+  private async grantTokens(
+    wsId: string,
+    user: AuthUser,
+    folder: string,
+    root: string,
+    summary?: string,
+  ): Promise<boolean> {
     const [read, write] = this.tokens(folder);
     const a = await this.mutation.grant(wsId, 'folder', root, 'read', read);
     const b = await this.mutation.grant(wsId, 'folder', root, 'write', write);
-    if (a.changed || b.changed) {
-      await this.commits.runPendingCommit(wsId, DEFAULT_BRANCH, `${this.kbDirName}/${a.editPath}`, user);
-    }
+    if (!(a.changed || b.changed)) return false;
+    await this.commits.runPendingCommit(wsId, this.kb.defaultBranch, `${this.kbDirName}/${a.editPath}`, user, {
+      summary,
+    });
+    return true;
   }
 
   private rootOrThrow(raw: string): string {
@@ -345,6 +518,6 @@ export class PluginLinksService {
     this.links.invalidate();
     this.accessControl.invalidate(wsId);
     this.onChanged?.();
-    this.events?.emit({ kind: 'fs-tree-changed', workspaceId: wsId, branch: DEFAULT_BRANCH });
+    this.events?.emit({ kind: 'fs-tree-changed', workspaceId: wsId, branch: this.kb.defaultBranch });
   }
 }