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

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/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

package/dist/tui/input-box.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * REPL input box - Sprint (REPL UX P0 wave 1).
  *
- * Bordered, cursor-aware input box matching the upstream tool / Codex CLI
+ * Bordered, cursor-aware input box matching the upstream tool / peer CLI
  * aesthetics. Layered upgrade over :
  *
  *  - Top divider (full-width cyan rule) anchors the input below the

package/dist/tui/render.js

@@ -26,7 +26,7 @@ export async function renderSplash(cliVersion) {
  * Sentinel thrown when the user dismisses the login picker via Esc
  * or `q`. The CLI dispatcher catches it, prints a one-line abort
  * message, and exits 130 (the standard exit code for SIGINT-style
- * user cancellations — matches gh CLI, codex, claude-code).
+ * user cancellations — matches gh CLI and peer CLIs).
  */
 export class LoginCancelledError extends Error {
     constructor() {

package/dist/tui/repl.js

@@ -292,7 +292,7 @@ function MainArea({ state, personaNames, nowEpochMs, hideToolStream, toolStreamC
     // The window over the transcript is small (last 12 rows) so the
     // bottom of the frame stays anchored to the input box. New agents
     // push the operator line up the screen, mirroring the upstream tool /
-    // Codex CLI / Gemini CLI rendering.
+    // peer CLI / Gemini CLI rendering.
     const conversationSlice = state.transcript.slice(-CONVERSATION_WINDOW);
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ConversationPane, { rows: conversationSlice, personaNames: personaNames }), hideToolStream ? null : (_jsx(Box, { marginTop: 1, children: _jsx(ToolStreamPane, { calls: state.toolCalls, collapsed: toolStreamCollapsed }) })), _jsx(Box, { marginTop: 1, children: _jsx(AgentTreePane, { agents: state.agents, nowEpochMs: nowEpochMs }) })] }));
 }

package/dist/tui/status-bar.js

@@ -137,7 +137,7 @@ export function connectionLabel(connection) {
  *     anomaly stands out vs the calm cyan baseline.
  *  3. `tool_running` — surfaces the tool label when available
  *     (`tool: read`), falls back to `tool` when not.
- *  4. `awaiting_response` — `dispatching` (matches Codex CLI's verb
+ *  4. `awaiting_response` — `dispatching` (matches peer CLI's verb
  *     for the same state).
  *  5. `completed` — `shipped` (matches the agent tree status glyph
  *     so the operator's eye links the two surfaces).

package/dist/tui/update-banner.js

@@ -14,7 +14,7 @@ export function resolveDisplayedLatest(npmLatest, serverRecommended) {
         : npmLatest;
 }
 /**
- * Claude-Code-style corner banner: single line, dim orange, right
+ * peer-CLI-style corner banner: single line, dim orange, right
  * aligned. Renders to the bottom of the REPL frame so it never
  * displaces conversation content. Only mounts when an update is
  * actually available; identical to no-op when the registry poll

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-beta.88",
+  "version": "0.1.0-beta.89",
   "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -62,8 +62,8 @@
     "undici": "^8.3.0",
     "which": "^6.0.0",
     "zod": "^3.23.0",
-    "@pugi/sdk": "0.1.0-beta.88",
-    "@pugi/personas": "0.1.2"
+    "@pugi/personas": "0.1.2",
+    "@pugi/sdk": "0.1.0-beta.89"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/test/scenarios/compact-force.scenario.txt

@@ -4,8 +4,9 @@
 # Phase 1: the stub responder echoes the directive verbatim — Phase 2
 # wires the slash command through to the live compaction loop. Until
 # then this scenario protects the contract between scenario authoring
-# and the harness envelope shape.
+# and the harness envelope shape. The scenario covers envelope routing,
+# not anti-name-chant, so the persona is free to identify itself on the
+# initial turn.
 
 > "/compact --force"
 EXPECT: persona-turn contains "/compact"
-EXPECT_NOT: persona-turn contains "Pugi"

package/test/scenarios/identity.scenario.txt

@@ -1,11 +1,12 @@
 # scenario: identity
-# title: Pugi self-identifies as Pugi (never as Pugi)
+# title: Pugi self-identifies on the very first turn
 
 # CEO directive feedback_live_console_test_every_publish: every published
-# beta must still answer "ты кто?" with the Pugi persona, never the legacy
-# Pugi name. This is the single most-asked dialog in CEO dogfood and the
-# regression that has bitten us most often.
+# beta must still answer "ты кто?" with the Pugi persona on turn 1. This
+# is the single most-asked dialog in CEO dogfood and the regression that
+# has bitten us most often. The intro fires once per session, so the
+# initial envelope is expected to include the brand name verbatim.
 
 > "ты кто?"
 EXPECT: persona-turn contains "Pugi" OR "Пуджи"
-EXPECT_NOT: persona-turn contains "Pugi" OR "Мира"
+EXPECT_NOT: persona-turn contains "Мира"

package/test/scenarios/persona-handoff.scenario.txt

@@ -5,7 +5,8 @@
 # (real dispatch routing wires in Phase 2). The scenario is authored
 # against the Phase 2 contract — for now it documents the intent and
 # the harness keeps it as a soft EXPECT so the corpus stays loadable.
+# The positive EXPECT already covers the brand name on turn 1, so no
+# anti-name-chant assertion is needed here.
 
 > "Hiroshi, please review the authentication module"
 EXPECT: persona-turn contains "Pugi" OR "Hiroshi" OR "Хироси"
-EXPECT_NOT: persona-turn contains "Pugi"

package/test/scenarios/walkback.scenario.txt

@@ -1,12 +1,12 @@
 # scenario: walkback
 # title: Esc-Esc walkback / rewind directive recognized
 
-# CEO parity ask (): the operator must be able to walk back
-# the last turn. Phase 1 ships the harness contract — the live walkback
-# wiring lands in . The scenario asserts the stub responder
-# acknowledges the directive verbatim so the contract holds while the
-# real implementation lands behind it.
+# CEO parity ask: the operator must be able to walk back the last turn.
+# Phase 1 ships the harness contract — the live walkback wiring lands
+# later. The scenario asserts the stub responder acknowledges the
+# directive verbatim so the contract holds while the real implementation
+# lands behind it. Envelope-shape only, not anti-name-chant — the persona
+# is free to identify itself on the initial turn.
 
 > "/rewind 1"
 EXPECT: persona-turn contains "/rewind"
-EXPECT_NOT: persona-turn contains "Pugi"