@pugi/cli 0.1.0-beta.87 → 0.1.0-beta.89

package/dist/tools/ask-user-question.js

@@ -48,6 +48,22 @@ export const ASK_USER_QUESTION_OPTION_DESC_MAX = 200;
 /** Option count: 2-4 strict. UI adds "Other" automatically. */
 export const ASK_USER_QUESTION_OPTIONS_MIN = 2;
 export const ASK_USER_QUESTION_OPTIONS_MAX = 4;
+/** PUGI-480 short-format chip rules: ≤ 5 words / option label, ≤ 3 questions / call. */
+export const ASK_USER_QUESTION_CHIP_LABEL_WORD_MAX = 5;
+export const ASK_USER_QUESTION_CHIPS_MAX = 3;
+/**
+ * Reusable validator for option labels rendered в chip mode.
+ * Counts whitespace-delimited words. Throws с a clear message that
+ * names the offending question + option so the model can self-correct.
+ */
+export function assertChipLabelWordCap(questionHeader, optionLabel) {
+    const words = optionLabel.trim().split(/\s+/u).filter((w) => w.length > 0);
+    if (words.length > ASK_USER_QUESTION_CHIP_LABEL_WORD_MAX) {
+        throw new Error(`ask_user_question chip "${questionHeader}" option "${optionLabel}" ` +
+            `exceeds the ${ASK_USER_QUESTION_CHIP_LABEL_WORD_MAX}-word label cap ` +
+            `(saw ${words.length} words). Shorten the label before dispatch.`);
+    }
+}
 /**
  * Structured option. `label` is the display text; `description` is the
  * implication line shown dim below it. Both are required — the model
@@ -100,6 +116,56 @@ export const askUserQuestionSchema = z.strictObject({
         .default(false)
         .describe('Allow multiple selections. Default false.'),
 });
+/**
+ * PUGI-480 multi-question chip payload — a bundle of up to 3 short-format
+ * chip questions rendered side-by-side. Schema is intentionally narrow:
+ * the chip renderer relies on the ≤ 5-word label invariant и will
+ * truncate с "…" if the model ever bypasses Zod. The 3-question cap
+ * forecloses paragraph-wall prompts at the schema level — the model
+ * cannot legally ask "10 quick questions" in one shot.
+ */
+export const askUserQuestionChipsQuestionSchema = z.strictObject({
+    header: z
+        .string()
+        .min(ASK_USER_QUESTION_HEADER_MIN)
+        .max(ASK_USER_QUESTION_HEADER_MAX)
+        .describe('Short chip label (max 12 chars). E.g. "Stack".'),
+    question: z
+        .string()
+        .min(ASK_USER_QUESTION_MIN)
+        .max(ASK_USER_QUESTION_MAX)
+        .optional()
+        .describe('Optional full-prose question (shown in non-TTY fallback only).'),
+    options: z
+        .array(askUserQuestionOptionSchema)
+        .min(ASK_USER_QUESTION_OPTIONS_MIN)
+        .max(ASK_USER_QUESTION_OPTIONS_MAX + 1)
+        .superRefine((opts, ctx) => {
+        // Enforce ≤ 5-word label cap on every option. Schema-level so
+        // the model gets immediate feedback on overflow rather than a
+        // silent truncation at render time.
+        for (const opt of opts) {
+            const words = opt.label
+                .trim()
+                .split(/\s+/u)
+                .filter((w) => w.length > 0);
+            if (words.length > ASK_USER_QUESTION_CHIP_LABEL_WORD_MAX) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `option "${opt.label}" has ${words.length} words; chip labels must be ≤ ${ASK_USER_QUESTION_CHIP_LABEL_WORD_MAX} words`,
+                });
+            }
+        }
+    })
+        .describe('2-5 mutually-exclusive options. Each label ≤ 5 words. UI inserts "Skip — use defaults" as a final option when defaults are present.'),
+});
+export const askUserQuestionChipsSchema = z.strictObject({
+    questions: z
+        .array(askUserQuestionChipsQuestionSchema)
+        .min(1)
+        .max(ASK_USER_QUESTION_CHIPS_MAX)
+        .describe('Bundle of 1-3 short clarifier questions rendered side-by-side as chips.'),
+});
 /**
  * Dispatch the structured tool: validate args via Zod, then route
  * through the shared `askUser` primitive so abort/timeout/non-TTY

package/dist/tools/bash.js

@@ -23,7 +23,7 @@
  *     `jobId`. `listJobs()` and `killJob(jobId)` are exported.
  *  5. 60s default timeout. SIGTERM at deadline, SIGKILL 5s later.
  *     Emit `bash.timeout`.
- *  6. POSIX-only (`/bin/sh`). The non-goal in ADR-0056 explicitly
+ *  6. POSIX-only (`/bin/sh`). The non-goal in  explicitly
  *     drops Windows shell support for M1.
  */
 import { randomUUID } from 'node:crypto';
@@ -191,7 +191,7 @@ export async function bashTool(input, ctx) {
             };
         }
     }
-    // POSIX-only `/bin/sh -c <cmd>`. The ADR-0056 non-goals explicitly
+    // POSIX-only `/bin/sh -c <cmd>`. The  non-goals explicitly
     // exclude Windows for M1.
     //
     // stdio layout:

package/dist/tools/lsp-tools.js

@@ -1,5 +1,7 @@
+import { callHierarchyAt, codeActionsAt, diagnosticsFor, findDefinition as symbolsFindDefinition, findImplementations, findReferences as symbolsFindReferences, findTypeDefinition, findWorkspaceSymbol, formatFile, hoverSymbol, listDocumentSymbols, renameSymbol, signatureAt, transportFromLspClient, } from '../core/lsp/symbol-tools.js';
 import { gateOnCancellation, OperatorAbortedError } from './file-tools.js';
 import { recordToolCall, recordToolResult } from '../core/session.js';
+import { getGlobalSymbolCache, SymbolCache } from '../core/lsp/symbol-cache.js';
 /** Cap for any single LSP tool's payload size. Keeps model context lean. */
 const LSP_PAYLOAD_CAP_BYTES = 8 * 1024;
 export async function lspHover(ctx, lang, file, line, col) {
@@ -184,6 +186,380 @@ function capDiagnostics(items) {
     }
     return { value: items.slice(0, 1), truncated: true };
 }
+/* ------------------------------------------------------------------------- */
+/* PUGI-78 Phase 1: symbols.* namespace tools (13 categories).               */
+/* ------------------------------------------------------------------------- */
+/**
+ * PUGI-78 Phase 1: symbols.find_definition.
+ *
+ * Pugi reads a whole file (~5-50 KB tokens) every time the model wants
+ * to know "where is foo defined?". The LSP wire here returns ~200 bytes
+ * (file + line + character). Two orders of magnitude reduction in token
+ * cost per refactor turn, hence the BIG-leverage classification in the
+ * spec (10-100x token savings per refactor).
+ *
+ * Failure folds to `lsp_unavailable` when no client is registered for
+ * the inferred language. The agent surface is expected to fall back to
+ * grep when this fires (the tool-preference prompt rule steers it).
+ */
+export async function symbolsFindDefinitionTool(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_find_definition', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'symbols_find_definition', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const cache = getSymbolCacheFromCtx(ctx);
+        const cwd = workspaceForCache(ctx);
+        const key = SymbolCache.makeKey(lang, cwd, 'find_definition', { file, line, col });
+        const cached = cache?.get(key);
+        if (cached !== undefined) {
+            if (cached === null)
+                return notFound('definition');
+            return { ok: true, value: cached };
+        }
+        const result = await symbolsFindDefinition(transportFromLspClient(client), file, line, col);
+        cache?.set(key, result);
+        if (!result)
+            return notFound('definition');
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.find_references.
+ *
+ * Returns the flat list of call sites for the symbol at (line, col).
+ * The 200-row cap from the legacy `lspReferences` carries over via
+ * `capSymbolReferences`.
+ */
+export async function symbolsFindReferencesTool(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_find_references', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'symbols_find_references', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const cache = getSymbolCacheFromCtx(ctx);
+        const cwd = workspaceForCache(ctx);
+        const key = SymbolCache.makeKey(lang, cwd, 'find_references', { file, line, col });
+        const cached = cache?.get(key);
+        if (cached !== undefined) {
+            const capped = capSymbolReferences(cached);
+            return { ok: true, value: capped.value, ...(capped.truncated ? { truncated: true } : {}) };
+        }
+        const result = await symbolsFindReferences(transportFromLspClient(client), file, line, col);
+        cache?.set(key, result);
+        const capped = capSymbolReferences(result);
+        return { ok: true, value: capped.value, ...(capped.truncated ? { truncated: true } : {}) };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.list_in_file.
+ *
+ * Outline view — the document-symbol surface. Returns the flat list of
+ * top-level + nested symbols with their kind. Cache HIT on the same
+ * file across consecutive turns is the common case (the model usually
+ * lists, then dives into a single symbol).
+ */
+export async function symbolsListInFileTool(ctx, lang, file) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_list_in_file', `${lang}:${file}`);
+    return guard(ctx, 'symbols_list_in_file', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const cache = getSymbolCacheFromCtx(ctx);
+        const cwd = workspaceForCache(ctx);
+        const key = SymbolCache.makeKey(lang, cwd, 'list_in_file', { file });
+        const cached = cache?.get(key);
+        if (cached !== undefined) {
+            return { ok: true, value: [...cached] };
+        }
+        const result = await listDocumentSymbols(transportFromLspClient(client), file);
+        cache?.set(key, result);
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.rename.
+ *
+ * Returns the workspace-edit preview the server proposes. The
+ * dispatcher applies via `apply_patch` in a future ticket; Phase 1 is
+ * read-only — the agent surface gets the affected file list + per-edit
+ * line/character so the model can summarize the change.
+ */
+export async function symbolsRenameTool(ctx, lang, file, line, col, newName) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_rename', `${lang}:${file}:${line}:${col}:${newName}`);
+    return guard(ctx, 'symbols_rename', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        // No cache for rename — the edit set depends on the live source
+        // file state. A subsequent rename of the same symbol after the
+        // first applied would otherwise return stale edits.
+        const result = await renameSymbol(transportFromLspClient(client), file, line, col, newName);
+        if (!result)
+            return notFound('rename');
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.hover.
+ *
+ * Returns the hover content (type info + docstring) at the position.
+ * Body capped at 4 KB so a verbose generic does not blow context.
+ */
+export async function symbolsHoverTool(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_hover', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'symbols_hover', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const cache = getSymbolCacheFromCtx(ctx);
+        const cwd = workspaceForCache(ctx);
+        const key = SymbolCache.makeKey(lang, cwd, 'hover', { file, line, col });
+        const cached = cache?.get(key);
+        if (cached !== undefined) {
+            if (cached === null)
+                return notFound('hover');
+            const next = {
+                ok: true,
+                value: { content: cached.content, ...(cached.range ? { range: cached.range } : {}) },
+                ...(cached.truncated ? { truncated: true } : {}),
+            };
+            return next;
+        }
+        const result = await hoverSymbol(transportFromLspClient(client), file, line, col);
+        cache?.set(key, result);
+        if (!result)
+            return notFound('hover');
+        return {
+            ok: true,
+            value: { content: result.content, ...(result.range ? { range: result.range } : {}) },
+            ...(result.truncated ? { truncated: true } : {}),
+        };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.signature.
+ *
+ * Function signature at a call site. Returns the active overload's
+ * label, parameters, and active-parameter index.
+ */
+export async function symbolsSignatureTool(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_signature', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'symbols_signature', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const result = await signatureAt(transportFromLspClient(client), file, line, col);
+        if (!result)
+            return notFound('signature');
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.workspace_symbols.
+ *
+ * Workspace-wide fuzzy search. The server picks the matching algorithm
+ * (substring / fuzzy / prefix); we forward verbatim.
+ */
+export async function symbolsWorkspaceSymbolsTool(ctx, lang, query) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_workspace_symbols', `${lang}:${query}`);
+    return guard(ctx, 'symbols_workspace_symbols', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const cache = getSymbolCacheFromCtx(ctx);
+        const cwd = workspaceForCache(ctx);
+        const key = SymbolCache.makeKey(lang, cwd, 'workspace_symbols', { query });
+        const cached = cache?.get(key);
+        if (cached !== undefined) {
+            return { ok: true, value: [...cached] };
+        }
+        const result = await findWorkspaceSymbol(transportFromLspClient(client), query);
+        cache?.set(key, result);
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.call_hierarchy.
+ *
+ * Returns the incoming + outgoing call edges at the symbol position.
+ * The two arrays are independent — a function may have many incoming
+ * callers and zero outgoing calls (a pure leaf), or vice versa.
+ */
+export async function symbolsCallHierarchyTool(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_call_hierarchy', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'symbols_call_hierarchy', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const cache = getSymbolCacheFromCtx(ctx);
+        const cwd = workspaceForCache(ctx);
+        const key = SymbolCache.makeKey(lang, cwd, 'call_hierarchy', { file, line, col });
+        const cached = cache?.get(key);
+        if (cached !== undefined) {
+            return { ok: true, value: { incoming: [...cached.incoming], outgoing: [...cached.outgoing] } };
+        }
+        const result = await callHierarchyAt(transportFromLspClient(client), file, line, col);
+        cache?.set(key, result);
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.implementations.
+ *
+ * Implementations of an interface / abstract method. Returns the flat
+ * list of concrete sites.
+ */
+export async function symbolsImplementationsTool(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_implementations', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'symbols_implementations', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const cache = getSymbolCacheFromCtx(ctx);
+        const cwd = workspaceForCache(ctx);
+        const key = SymbolCache.makeKey(lang, cwd, 'implementations', { file, line, col });
+        const cached = cache?.get(key);
+        if (cached !== undefined) {
+            const capped = capSymbolReferences(cached);
+            return { ok: true, value: capped.value, ...(capped.truncated ? { truncated: true } : {}) };
+        }
+        const result = await findImplementations(transportFromLspClient(client), file, line, col);
+        cache?.set(key, result);
+        const capped = capSymbolReferences(result);
+        return { ok: true, value: capped.value, ...(capped.truncated ? { truncated: true } : {}) };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.type_definition.
+ *
+ * Type definition (vs value definition). Useful for "what type is foo?"
+ * questions when the model has a variable and wants its type declaration.
+ */
+export async function symbolsTypeDefinitionTool(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_type_definition', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'symbols_type_definition', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const cache = getSymbolCacheFromCtx(ctx);
+        const cwd = workspaceForCache(ctx);
+        const key = SymbolCache.makeKey(lang, cwd, 'type_definition', { file, line, col });
+        const cached = cache?.get(key);
+        if (cached !== undefined) {
+            if (cached === null)
+                return notFound('type_definition');
+            return { ok: true, value: cached };
+        }
+        const result = await findTypeDefinition(transportFromLspClient(client), file, line, col);
+        cache?.set(key, result);
+        if (!result)
+            return notFound('type_definition');
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.code_actions.
+ *
+ * Quick-fix list at the given range. Server-provided actions include
+ * auto-import, unused-import removal, refactor extractions, etc.
+ */
+export async function symbolsCodeActionsTool(ctx, lang, file, startLine, startChar, endLine, endChar) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_code_actions', `${lang}:${file}:${startLine}:${startChar}-${endLine}:${endChar}`);
+    return guard(ctx, 'symbols_code_actions', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const result = await codeActionsAt(transportFromLspClient(client), file, startLine, startChar, endLine, endChar);
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.format.
+ *
+ * Formatter — returns the text edits the LSP server would apply for
+ * `textDocument/formatting`. Phase 1 is read-only (returns the edits);
+ * the dispatcher composes + applies in a future ticket.
+ */
+export async function symbolsFormatTool(ctx, lang, file, options) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_format', `${lang}:${file}`);
+    return guard(ctx, 'symbols_format', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const result = await formatFile(transportFromLspClient(client), file, options);
+        return { ok: true, value: result };
+    });
+}
+/**
+ * PUGI-78 Phase 1: symbols.diagnostics.
+ *
+ * Pulls the cached `publishDiagnostics` payload for the file. Mirrors
+ * the legacy `lspDiagnostics` tool but exposed via the namespaced
+ * `symbols.*` surface for discoverability.
+ */
+export async function symbolsDiagnosticsTool(ctx, lang, file) {
+    const toolCallId = recordToolCall(ctx.session, 'symbols_diagnostics', `${lang}:${file}`);
+    return guard(ctx, 'symbols_diagnostics', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const result = await diagnosticsFor(transportFromLspClient(client), file);
+        const capped = capDiagnostics(result);
+        return { ok: true, value: capped.value, ...(capped.truncated ? { truncated: true } : {}) };
+    });
+}
+function workspaceForCache(ctx) {
+    // ToolContext exposes `root` (the workspace root). Fall back to a
+    // tagged anonymous workspace when somehow absent so the cache still
+    // keys deterministically.
+    const root = ctx.root;
+    if (typeof root === 'string' && root.length > 0)
+        return root;
+    return '<unknown>';
+}
+function getSymbolCacheFromCtx(ctx) {
+    // The agent dispatcher injects an optional cache via the ctx — when
+    // present we use the dispatcher-scoped cache so test harnesses can
+    // inject a deterministic clock. When absent, we fall back to the
+    // process-global cache.
+    if (ctx.symbolCache)
+        return ctx.symbolCache;
+    return getGlobalSymbolCache();
+}
+function notFound(verb) {
+    return {
+        ok: false,
+        reason: 'lsp_not_found',
+        detail: `LSP returned no ${verb} for the requested position.`,
+    };
+}
+function capSymbolReferences(items) {
+    const COUNT_CAP = 200;
+    if (items.length === 0)
+        return { value: items, truncated: false };
+    const trimmed = items.slice(0, COUNT_CAP);
+    const serialized = JSON.stringify(trimmed);
+    if (Buffer.byteLength(serialized, 'utf8') <= LSP_PAYLOAD_CAP_BYTES && trimmed.length === items.length) {
+        return { value: trimmed, truncated: false };
+    }
+    let upper = trimmed.length;
+    while (upper > 1) {
+        const half = Math.floor(upper / 2);
+        const sub = trimmed.slice(0, half);
+        if (Buffer.byteLength(JSON.stringify(sub), 'utf8') <= LSP_PAYLOAD_CAP_BYTES) {
+            return { value: sub, truncated: true };
+        }
+        upper = half;
+    }
+    return { value: trimmed.slice(0, 1), truncated: true };
+}
 /** Test-only surface so specs can poke truncation directly. */
-export const __test__ = { truncate, capLocations, capDiagnostics, LSP_PAYLOAD_CAP_BYTES };
+export const __test__ = {
+    truncate,
+    capLocations,
+    capDiagnostics,
+    capSymbolReferences,
+    LSP_PAYLOAD_CAP_BYTES,
+};
 //# sourceMappingURL=lsp-tools.js.map

package/dist/tools/powershell.js

@@ -6,7 +6,7 @@
  * на cross-platform PowerShell 7+ binary so Windows-first workflows are
  * first-class на Pugi.
  *
- * Clean-room re-implementation. Surface mirrors bashTool's permission
+ * independent implementation re-implementation. Surface mirrors bashTool's permission
  * gate, env sanitiser, output cap, timeout, and exit-code propagation;
  * the only difference is the shell binary selection. Per-platform
  * resolution:

package/dist/tools/registry.js

@@ -43,6 +43,29 @@ const registry = [
     { name: 'lsp_diagnostics', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
     { name: 'lsp_hover', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
     { name: 'lsp_references', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
+    // PUGI-78 Phase 1 — symbols.* namespace. 13 first-class tools that
+    // expose the full LSP symbol-aware surface (definition, references,
+    // hover, signature, document/workspace symbols, rename preview, call
+    // hierarchy, implementations, type definition, code actions,
+    // formatter, diagnostics). All read-only in Phase 1 — `rename` /
+    // `format` / `code_actions` return PREVIEW edits the dispatcher
+    // applies via apply_patch in a future ticket. Permission stays
+    // `read` because no workspace mutation happens on dispatch; risk
+    // stays `low` because the LSP server is local and the payload is
+    // capped at 8 KB per tool.
+    { name: 'symbols_call_hierarchy', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_code_actions', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_diagnostics', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_find_definition', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_find_references', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_format', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_hover', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_implementations', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_list_in_file', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_rename', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_signature', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_type_definition', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
+    { name: 'symbols_workspace_symbols', permission: 'read', risk: 'low', concurrencySafe: true, m1: false },
     // β7 L5+T11: multi_edit dispatches an ordered batch of Layer A edits
     // as a single transaction. Risk = medium (same chokepoints as `edit`).
     // concurrencySafe = false because the journal serialises one dispatch