@pugi/cli 0.1.0-alpha.10 → 0.1.0-alpha.16

package/dist/core/repl/session.js

@@ -27,18 +27,32 @@
  * verbatim - the brand gate on those happens at the controller.
  */
 import { randomUUID } from 'node:crypto';
+import { getPersona } from '@pugi/personas';
 import { listRoles, getPersonaForRole } from '../agents/registry.js';
 import { evaluateCap, describeVerdict } from './cap-warning.js';
 import { parseSlashCommand } from './slash-commands.js';
 import { webFetchTool } from '../../tools/web-fetch.js';
 import { loadSettings } from '../settings.js';
 import { getJobRegistry } from '../jobs/registry.js';
+import { extractAskTags, extractPlanReviewTags, signatureForAsk, } from './ask.js';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 const MAX_TRANSCRIPT_ROWS = 500;
+const MAX_TOOL_CALLS = 200;
 const MAX_RECONNECT_ATTEMPTS = 10;
 const RECONNECT_BASE_MS = 250;
 const RECONNECT_MAX_MS = 5_000;
+/**
+ * Cap on silent session-recreate attempts on HTTP 404 from the SSE
+ * stream. When admin-api restarts it drops its in-memory session
+ * store, so the saved sessionId returns 404 on every subscribe. The
+ * CLI mints a fresh server session, swaps the consumer over, and
+ * keeps running — but we cap the recovery to 3 attempts inside 60s
+ * so a truly down admin-api fails loud instead of spinning forever.
+ * (α6.14.2 wave 5 — CEO dogfood fix.)
+ */
+const MAX_SESSION_RECREATE_ATTEMPTS = 3;
+const SESSION_RECREATE_WINDOW_MS = 60_000;
 export class ReplSession {
     options;
     subscribers = new Set();
@@ -48,6 +62,22 @@ export class ReplSession {
     reconnectAttempt = 0;
     reconnectTimer;
     closed = false;
+    /**
+     * Rolling window of recent silent-recreate timestamps (epoch ms).
+     * The SSE stream returns HTTP 404 when admin-api has restarted and
+     * lost its in-memory session store; rather than spam the operator
+     * with "Stream interrupted (HTTP 404)" loops, we mint a fresh
+     * session and swap the consumer. Capped at MAX_SESSION_RECREATE_*
+     * inside SESSION_RECREATE_WINDOW_MS so a permanently down admin-api
+     * fails loud instead of looping silently. (α6.14.2 wave 5.)
+     */
+    recentRecreateAtMs = [];
+    /**
+     * True while a session-recreate POST is in flight. Guards against
+     * the SSE stream firing multiple `onError(404)` callbacks racing
+     * the in-flight createSession promise. (α6.14.2 wave 5.)
+     */
+    recreatingSession = false;
     /**
      * Last non-trivial step.detail recorded per taskId. The server streams
      * the persona reply incrementally via `agent.step` events whose
@@ -60,17 +90,74 @@ export class ReplSession {
      * said. CEO wave-2 fix 2026-05-25.
      */
     lastStepDetail = new Map();
+    /**
+     * Optional local SessionStore — α6.4. When non-null, every
+     * appendRow() call mirrors the row into the JSONL log so the
+     * conversation can be restored via `/resume`. Errors from the store
+     * are swallowed to a single system line (degradation, not crash).
+     * The store is opened by the CLI bootstrap and closed via
+     * `ReplSession.close()`. The store ownership is shared — the
+     * SqliteSessionStore is process-wide singleton-ish under the
+     * lockfile, so close-on-quit is safe.
+     */
+    store;
+    /**
+     * Local session id used as the persistence key. Distinct from the
+     * server-side sessionId issued by admin-api in state.sessionId.
+     * When the operator runs `pugi resume <id>`, the CLI passes the id
+     * via `localSessionId` so the JSONL log keeps growing under the
+     * original id rather than fragmenting into a new one.
+     */
+    localSessionId;
+    /**
+     * One-shot guard so a store error only emits ONE system line per
+     * session — without this, a stuck filesystem would spam the operator
+     * with `[store]` errors on every keystroke.
+     */
+    storeErrorEmitted = false;
+    /**
+     * Rolling dedupe set for `<pugi-ask>` and `<pugi-plan-review>`
+     * signatures. The persona may emit the same envelope twice on network
+     * retry; we suppress the duplicate so the operator does not see two
+     * stacked modals. Capped at 32 entries — generous for a real session,
+     * defensive against a hostile flood. (α6.3.)
+     */
+    seenTagSignatures = [];
+    /**
+     * Per-task buffer for streaming tag detection. The persona's
+     * `<pugi-ask>` open and close tags may arrive in separate
+     * `agent.step` events when the upstream LLM token-streams output
+     * char-by-char. We accumulate the running detail per taskId until a
+     * complete envelope lands OR the turn ends. (α6.3.)
+     */
+    askBuffer = new Map();
+    /**
+     * Tracks taskIds that had an `<pugi-ask>` or `<pugi-plan-review>`
+     * envelope mid-stream the last time the parser ran on the buffer. If
+     * the turn ends with this flag still set, we emit a system-line
+     * warning that the persona produced an incomplete tag - the partial
+     * XML is silently dropped (the parser already withheld it from the
+     * cleaned body). Codex triple-review P2 (PR #375).
+     */
+    askBufferPending = new Set();
     constructor(options) {
         this.options = options;
+        this.store = options.store ?? null;
+        this.localSessionId = options.localSessionId;
         this.state = {
             sessionId: undefined,
             workspaceLabel: options.workspaceLabel,
             cliVersion: options.cliVersion,
             connection: 'connecting',
             agents: [],
+            toolCalls: [],
             transcript: [],
             tokensDownstreamTotal: 0,
             briefStartedAtEpochMs: undefined,
+            pendingAsk: null,
+            pendingAskSource: null,
+            pendingPlanReview: null,
+            pendingPlanReviewSource: null,
         };
     }
     /* ------------- subscribe / state -------------- */
@@ -183,12 +270,77 @@ export class ReplSession {
                 this.dispatchStatus();
                 return verdict;
             }
+            case 'consensus': {
+                // alpha 6.7: surface a deterministic deep-link so the operator
+                // knows the command exists in the REPL palette even though the
+                // full SSE renderer ships outside the Ink frame. Running the
+                // gate live inside the REPL needs the non-TTY emit path; for
+                // M1 we point the operator at the shell command.
+                const tail = verdict.ref ? ` ${verdict.ref}` : '';
+                this.appendSystemLine(`Run \`pugi review --consensus${tail}\` from a fresh shell to dispatch the 3-model gate.`);
+                return verdict;
+            }
+            case 'resume': {
+                await this.dispatchResume();
+                return verdict;
+            }
+            case 'ask': {
+                // α6.3: synthesise a local yes/no `<pugi-ask>` modal so the
+                // operator can exercise the question UI without a persona-side
+                // round trip. The REPL UI mounts the modal from the resulting
+                // `pendingAsk` state; on resolution the encoded verdict lands
+                // in the transcript as a system line (no admin-api dispatch
+                // because the question is local).
+                const askTag = synthesiseLocalAskTag(verdict.question);
+                if (!askTag) {
+                    this.appendSystemLine('Could not synthesise local ask (question too long?). Cap is 80 chars.');
+                    return verdict;
+                }
+                this.patch({ pendingAsk: askTag, pendingAskSource: 'local' });
+                return verdict;
+            }
             case 'stub': {
                 this.appendSystemLine(verdict.message);
                 return verdict;
             }
         }
     }
+    /**
+     * In-REPL `/resume` — α6.4. Lists the 10 most recent sessions from
+     * the local SessionStore and prints them as a numbered system menu.
+     * The Ink-side picker UI is deferred to the next sprint; today the
+     * operator gets a deterministic list + the exact command to relaunch
+     * with: `pugi resume <id>`. Keeping the picker out of the REPL
+     * frame avoids re-architecting the conversation pane mid-sprint and
+     * keeps `/resume` testable without an Ink runtime.
+     */
+    async dispatchResume() {
+        if (!this.store) {
+            this.appendSystemLine('Local session store is disabled - /resume is unavailable.');
+            return;
+        }
+        let rows;
+        try {
+            rows = await this.store.listSessions({ limit: 10 });
+        }
+        catch (error) {
+            this.appendSystemLine(`Could not list sessions: ${this.errorMessage(error)}`);
+            return;
+        }
+        if (rows.length === 0) {
+            this.appendSystemLine('No stored sessions yet - keep dispatching to build history.');
+            return;
+        }
+        this.appendSystemLine(`Recent sessions (${rows.length}):`);
+        for (let i = 0; i < rows.length; i += 1) {
+            const row = rows[i];
+            const title = (row.title ?? '(untitled)').slice(0, 64);
+            const idShort = row.id.slice(0, 13);
+            const branch = row.branch ?? 'no-branch';
+            this.appendSystemLine(`  ${(i + 1).toString().padStart(2)}. ${idShort}  ${branch.padEnd(16)}  ${title}`);
+        }
+        this.appendSystemLine('Pick one with: pugi resume <id> (paste the 13-char id from above).');
+    }
     /**
      * Reset the conversation transcript. The agent registry stays intact
      * so the operator can `/clear` to declutter the chat pane without
@@ -197,6 +349,173 @@ export class ReplSession {
     clearTranscript() {
         this.patch({ transcript: [] });
     }
+    /* ------------- α6.3 office-hours surface -------------- */
+    /**
+     * Surface an `<pugi-ask>` modal manually. Returned promise resolves
+     * with the operator's verdict — used by the `pugi ask "<q>"` shell
+     * command and by the `/ask` slash. The resolver is wired into the
+     * session state via `pendingAsk` so the REPL UI can render the modal
+     * and forward `onResolve` back through `resolveAsk()`.
+     *
+     * NOTE: idempotent on a duplicate signature — a second presentAsk
+     * with the same question + option values returns the first
+     * outstanding promise rather than stacking two modals.
+     */
+    presentAsk(tag) {
+        if (this.outstandingAskPromise
+            && this.state.pendingAsk?.signature === tag.signature) {
+            // The operator is already looking at this exact ask; reuse the
+            // outstanding promise so the second caller sees the same answer
+            // when it eventually arrives.
+            return this.outstandingAskPromise;
+        }
+        // If a DIFFERENT ask is open, reject the new one with a clear
+        // error rather than silently queueing — the persona should never
+        // emit two concurrent asks, and surfacing the bug fails loud.
+        if (this.outstandingAskPromise) {
+            return Promise.reject(new Error('presentAsk: another ask is already pending. Resolve it first.'));
+        }
+        this.patch({ pendingAsk: tag, pendingAskSource: 'persona' });
+        const promise = new Promise((resolve) => {
+            this.outstandingAskResolver = resolve;
+        });
+        this.outstandingAskPromise = promise;
+        return promise;
+    }
+    /**
+     * Resolve the currently pending `<pugi-ask>` modal. Called by the
+     * REPL UI when the operator submits the modal. Appends an operator
+     * line to the transcript carrying the verdict, dispatches the
+     * verdict-encoded brief to admin-api as the next user turn (when the
+     * modal originated from a persona stream), and clears `pendingAsk`.
+     * Idempotent: a second call without a fresh `pendingAsk` is a no-op.
+     *
+     * The verdict is also forwarded to the resolver returned by
+     * `presentAsk()` if there is one outstanding, so the CLI's `pugi ask`
+     * command can await the answer.
+     *
+     * Cancellation contract (Claude triple-review P1): when the modal
+     * came from a persona stream, cancel ALSO dispatches a literal
+     * `[ASK-RESPONSE:cancelled]` to admin-api so the persona observes the
+     * cancellation rather than hanging indefinitely on the missing
+     * follow-up. The matching documentation in the Mira system prompt
+     * teaches the persona to acknowledge cancellation and offer a
+     * different path. Local-origin modals (synthesised via `/ask`) skip
+     * the dispatch entirely - the persona never saw the question.
+     *
+     * Free-text sanitisation (Claude triple-review P1): the operator's
+     * customInput is stripped of any leading `[ASK-RESPONSE:...]` /
+     * `[PLAN-VERDICT:...]` prefix before being encoded, so a malicious
+     * (or accidental) operator string cannot forge a verdict header that
+     * a prefix-greedy persona would misinterpret as a different choice.
+     */
+    async resolveAsk(verdict) {
+        if (!this.state.pendingAsk)
+            return;
+        const tag = this.state.pendingAsk;
+        const source = this.state.pendingAskSource;
+        const sanitisedVerdict = sanitiseAskVerdict(verdict);
+        this.patch({ pendingAsk: null, pendingAskSource: null });
+        const encoded = encodeAskVerdictLocal(sanitisedVerdict);
+        // Tell the outstanding presentAsk caller, if any. The sanitised
+        // verdict is forwarded so downstream consumers cannot be tricked
+        // by a forged verdict header either.
+        if (this.outstandingAskResolver) {
+            const resolver = this.outstandingAskResolver;
+            this.outstandingAskResolver = undefined;
+            this.outstandingAskPromise = undefined;
+            resolver(sanitisedVerdict);
+        }
+        // Surface the operator's choice as a transcript row so the
+        // conversation reads linearly. The label of the chosen option
+        // (or the literal custom input) is more readable than the bare
+        // value - Codex CLI's "you chose: Vercel" pattern.
+        const humanLabel = humanLabelForVerdict(tag, sanitisedVerdict);
+        this.appendOperatorLine(humanLabel);
+        // Local-origin modals (operator typed `/ask`) never need an
+        // admin-api round trip - the persona never observed the question.
+        // Codex triple-review P2.
+        if (source !== 'persona')
+            return;
+        // Persona-origin modals always dispatch, including on cancel:
+        // without the cancellation echo the persona's last turn stays open
+        // and the agent hangs. Claude triple-review P1.
+        await this.dispatchAskFollowup(encoded);
+    }
+    /**
+     * Same shape as `presentAsk` for the plan-review modal.
+     */
+    presentPlanReview(tag) {
+        if (this.outstandingPlanReviewPromise
+            && this.state.pendingPlanReview?.signature === tag.signature) {
+            return this.outstandingPlanReviewPromise;
+        }
+        if (this.outstandingPlanReviewPromise) {
+            return Promise.reject(new Error('presentPlanReview: another plan review is already pending.'));
+        }
+        this.patch({ pendingPlanReview: tag, pendingPlanReviewSource: 'persona' });
+        const promise = new Promise((resolve) => {
+            this.outstandingPlanReviewResolver = resolve;
+        });
+        this.outstandingPlanReviewPromise = promise;
+        return promise;
+    }
+    /**
+     * Resolve the currently pending `<pugi-plan-review>` modal. Same
+     * mechanics as `resolveAsk` - including the cancel-dispatch contract
+     * and modifyText sanitisation. The persona always sees a
+     * `[PLAN-VERDICT:...]` echo (even on cancel) so it never hangs
+     * waiting for the verdict that the operator declined to send.
+     */
+    async resolvePlanReview(result) {
+        if (!this.state.pendingPlanReview)
+            return;
+        const source = this.state.pendingPlanReviewSource;
+        const sanitisedResult = sanitisePlanReviewResult(result);
+        this.patch({ pendingPlanReview: null, pendingPlanReviewSource: null });
+        const encoded = encodePlanReviewVerdictLocal(sanitisedResult);
+        if (this.outstandingPlanReviewResolver) {
+            const resolver = this.outstandingPlanReviewResolver;
+            this.outstandingPlanReviewResolver = undefined;
+            this.outstandingPlanReviewPromise = undefined;
+            resolver(sanitisedResult);
+        }
+        this.appendOperatorLine(humanLabelForPlanReviewVerdict(sanitisedResult));
+        // Local-origin plan reviews skip the dispatch (Codex P2). Persona
+        // origin always dispatches, including on cancel (Claude P1).
+        if (source !== 'persona')
+            return;
+        await this.dispatchAskFollowup(encoded);
+    }
+    /**
+     * Internal: post the verdict-encoded brief WITHOUT going through the
+     * cap-warning gate. The follow-up is the natural continuation of the
+     * same conversation the persona started, so blocking it on capacity
+     * would strand the operator with no way to answer.
+     */
+    async dispatchAskFollowup(encodedBrief) {
+        const sessionId = this.state.sessionId;
+        if (!sessionId) {
+            this.appendSystemLine('No server session - response queued locally.');
+            return;
+        }
+        try {
+            await this.options.transport.postBrief({
+                apiUrl: this.options.apiUrl,
+                apiKey: this.options.apiKey,
+                sessionId,
+                brief: encodedBrief,
+            });
+        }
+        catch (error) {
+            this.appendSystemLine(`Could not forward response: ${this.errorMessage(error)}`);
+        }
+    }
+    // ----- Outstanding resolver bookkeeping for presentAsk / presentPlanReview -----
+    outstandingAskResolver;
+    outstandingAskPromise;
+    outstandingPlanReviewResolver;
+    outstandingPlanReviewPromise;
     /* ------------- Tier 1 / Tier 2 wired handlers -------------- */
     async dispatchJobs() {
         try {
@@ -382,12 +701,118 @@ export class ReplSession {
             onError: (error) => {
                 if (this.closed)
                     return;
+                // α6.14.2 wave 5: when admin-api restarts it drops the in-memory
+                // session store, so subscribe returns HTTP 404 forever on the
+                // saved sessionId. Detect that case and mint a fresh server
+                // session silently rather than spamming the operator with
+                // "Stream interrupted (HTTP 404)" reconnect lines. Capped to
+                // MAX_SESSION_RECREATE_ATTEMPTS inside SESSION_RECREATE_WINDOW_MS
+                // so a permanently down admin-api fails loud.
+                //
+                // Race guard (triple-review P2 follow-up): the SSE transport can
+                // fire onError synchronously a second time while we are tearing
+                // down the dead stream inside recreateSessionSilently (the
+                // streamHandle.close() call there can flush a pending error
+                // synchronously in some transports). If that second 404 arrives
+                // with recreatingSession === true, we must SHORT-CIRCUIT it too
+                // rather than fall through to the legacy "Stream interrupted"
+                // path — otherwise the operator sees the exact 404 line the
+                // recreate is trying to suppress.
+                if (this.isSessionNotFoundError(error)) {
+                    if (this.recreatingSession) {
+                        // Recreate already in flight — drop the duplicate 404 on the
+                        // floor. The first recreate will either succeed (new stream
+                        // opens, this dead handle is gone) or fall through to the
+                        // loud "keeps dropping" / "session recreate refused" paths
+                        // already defined in recreateSessionSilently.
+                        return;
+                    }
+                    this.patch({ connection: 'reconnecting' });
+                    void this.recreateSessionSilently();
+                    return;
+                }
                 this.patch({ connection: 'reconnecting' });
                 this.appendSystemLine(`Stream interrupted (${this.errorMessage(error)}). Reconnecting.`);
                 this.scheduleReconnect();
             },
         });
     }
+    /**
+     * Detect "session not found" from the SSE transport. The production
+     * transport in `repl-render.tsx` wraps non-2xx responses as
+     * `Error("HTTP 404 on SSE stream")`. We pattern-match on the status
+     * 404 so a different transport (e.g. a test fake or a future polling
+     * fallback) can surface the same intent with the same shape.
+     * (α6.14.2 wave 5.)
+     */
+    isSessionNotFoundError(error) {
+        const msg = this.errorMessage(error);
+        return /\b404\b/.test(msg);
+    }
+    /**
+     * Mint a fresh server-side session, swap the consumer to the new
+     * stream URL, keep the conversation flowing. Caps at
+     * MAX_SESSION_RECREATE_ATTEMPTS inside SESSION_RECREATE_WINDOW_MS so
+     * a permanently down admin-api fails loud after a few seconds of
+     * trying. Logged once per attempt at debug level (we surface a
+     * single visible line on first auto-recreate so the operator knows
+     * what happened, then stay quiet). (α6.14.2 wave 5.)
+     */
+    async recreateSessionSilently() {
+        if (this.closed)
+            return;
+        if (this.recreatingSession)
+            return;
+        const nowMs = this.now();
+        // Drop stale window entries so the cap is rolling, not cumulative.
+        while (this.recentRecreateAtMs.length > 0
+            && nowMs - (this.recentRecreateAtMs[0] ?? 0) > SESSION_RECREATE_WINDOW_MS) {
+            this.recentRecreateAtMs.shift();
+        }
+        if (this.recentRecreateAtMs.length >= MAX_SESSION_RECREATE_ATTEMPTS) {
+            // Cap exceeded — fall back to the loud "give up" path so the
+            // operator sees something is actually wrong.
+            this.appendSystemLine('Admin API session keeps dropping (HTTP 404 x3). Type /quit and `pugi resume` to retry.');
+            this.patch({ connection: 'offline' });
+            return;
+        }
+        this.recreatingSession = true;
+        this.recentRecreateAtMs.push(nowMs);
+        // Tear down the dead SSE handle so the next openStream() does not
+        // close-over the stale sessionId.
+        if (this.streamHandle) {
+            this.streamHandle.close();
+            this.streamHandle = undefined;
+        }
+        // Reset reconnect attempt + lastEventId — the new session is a
+        // fresh stream, not a continuation of the dead one.
+        this.reconnectAttempt = 0;
+        this.lastEventId = undefined;
+        // Single visible line on the FIRST auto-recreate of the window so
+        // the operator knows the CLI is recovering; later recreates in
+        // the same window stay silent.
+        if (this.recentRecreateAtMs.length === 1) {
+            this.appendSystemLine('Admin API restarted - minting a fresh session.');
+        }
+        try {
+            const { sessionId } = await this.options.transport.createSession({
+                apiUrl: this.options.apiUrl,
+                apiKey: this.options.apiKey,
+                workspace: this.options.workspace,
+            });
+            this.patch({ sessionId, connection: 'connecting' });
+            this.openStream();
+        }
+        catch (error) {
+            // The recreate POST itself failed — fall back to the existing
+            // backoff reconnect so the operator still sees retry progress.
+            this.appendSystemLine(`Session recreate refused (${this.errorMessage(error)}). Reconnecting.`);
+            this.scheduleReconnect();
+        }
+        finally {
+            this.recreatingSession = false;
+        }
+    }
     scheduleReconnect() {
         if (this.closed)
             return;
@@ -411,7 +836,7 @@ export class ReplSession {
                 // Wave 4 fix 2026-05-25: the roster collapses to one row per
                 // persona slug. The α5.7 reducer pushed a fresh row on every
                 // spawn, so after three turns the bottom panel stacked
-                // "Mira orchestrator shipped" three times. The new contract:
+                // "Pugi orchestrator shipped" three times. The new contract:
                 //   - If a row already exists for this personaSlug, REUSE it.
                 //     Replace its taskId, reset status to 'queued', clear the
                 //     detail line, restart the duration clock, zero the token
@@ -447,20 +872,46 @@ export class ReplSession {
                 // double-print. `void persona` keeps the resolved name in scope
                 // for the agent tree node above without leaking it into the
                 // transcript body.
+                // α6.14.3 CEO dogfood 2026-05-25: drop the "dispatched (X)"
+                // transcript echo. The agent tree pane already shows the
+                // spawned state; printing it as a persona row is pure noise
+                // between the operator's brief and the persona's real reply.
                 void persona;
-                this.appendPersonaLine(event.personaSlug, `dispatched (${event.role}).`);
                 return;
             }
             case 'agent.step': {
+                // α6.3 office-hours: scan the running buffer for `<pugi-ask>` /
+                // `<pugi-plan-review>` envelopes BEFORE we cache the detail.
+                // The parser returns the cleaned remainder with the raw XML
+                // stripped, so the operator never sees the envelope as prose.
+                // Streaming partial tags (open seen, close not yet streamed)
+                // are kept in the buffer; the next step event extends it.
+                const sanitised = this.consumeAskAndPlanReviewTags(event.taskId, event.detail);
                 // Cache the running detail per task so we can surface the
                 // model's actual reply when agent.completed lands (otherwise
                 // the reply disappears under the literal 'shipped' patch).
-                if (event.detail && event.detail.trim().length > 0) {
-                    this.lastStepDetail.set(event.taskId, event.detail);
+                if (sanitised && sanitised.trim().length > 0) {
+                    this.lastStepDetail.set(event.taskId, sanitised);
+                }
+                // α6.12: synthesise a tool call entry when the step detail
+                // matches a tool-invocation grammar. The pattern is generous
+                // (Read(path) / Edit(path:lines) / Bash(cmd) / Grep(pat) /
+                // Glob(pat) / WebFetch(url)) so the pane has rows to render
+                // before the admin-api side ships the proper tool.* SSE events.
+                // Use the sanitised detail (post-tag-strip) so a `<pugi-ask>`
+                // envelope never produces a phantom tool row.
+                const synthesised = synthesiseToolCall({
+                    taskId: event.taskId,
+                    detail: sanitised,
+                    agent: this.personaSlugForTask(event.taskId),
+                    now: this.now(),
+                });
+                if (synthesised) {
+                    this.appendToolCall(synthesised);
                 }
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
-                        ? { ...a, status: 'thinking', detail: event.detail }
+                        ? { ...a, status: 'thinking', detail: sanitised || event.detail }
                         : a),
                 });
                 return;
@@ -483,6 +934,11 @@ export class ReplSession {
                 const target = this.state.agents.find((a) => a.taskId === event.taskId);
                 const finalDetail = this.lastStepDetail.get(event.taskId);
                 this.lastStepDetail.delete(event.taskId);
+                if (this.askBufferPending.has(event.taskId)) {
+                    this.appendSystemLine('Persona emitted incomplete <pugi-ask> or <pugi-plan-review> tag; dropped.');
+                }
+                this.askBuffer.delete(event.taskId);
+                this.askBufferPending.delete(event.taskId);
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
                         ? { ...a, status: 'shipped', detail: 'shipped' }
@@ -500,15 +956,34 @@ export class ReplSession {
                     if (finalDetail
                         && finalDetail !== 'queued for dispatch'
                         && finalDetail.trim().length > 4) {
-                        for (const line of finalDetail.split('\n')) {
-                            const trimmed = line.trim();
-                            if (trimmed.length > 0) {
-                                this.appendPersonaLine(target.personaSlug, trimmed);
+                        // α6.12: ship the WHOLE body as one transcript row when the
+                        // reply contains ANY Markdown structure (code fence, bullet
+                        // list, numbered list, headings). The conversation pane
+                        // routes it through Markdown renderer в one pass, preserving
+                        // grouped bullets + heading hierarchy. Plain prose still
+                        // splits per line so word-wrap stays correct.
+                        //
+                        // Claude triple-review P1 (PR #369): the prior `includes('```')`
+                        // gate only caught fences — multi-line bullets fragmented
+                        // per row showed as `▸ Mira • read PUGI.md / ▸ Mira • patched
+                        // bug / ...` instead of a single grouped bullet block.
+                        if (looksLikeMarkdown(finalDetail)) {
+                            this.appendPersonaLine(target.personaSlug, finalDetail);
+                        }
+                        else {
+                            for (const line of finalDetail.split('\n')) {
+                                const trimmed = line.trim();
+                                if (trimmed.length > 0) {
+                                    this.appendPersonaLine(target.personaSlug, trimmed);
+                                }
                             }
                         }
                     }
                     else {
-                        this.appendPersonaLine(target.personaSlug, 'shipped.');
+                        // α6.14.3 CEO dogfood 2026-05-25: drop the literal
+                        // "shipped." fallback row. If we have no cached detail to
+                        // surface, stay silent. The agent tree pane already shows
+                        // the green check + duration.
                     }
                 }
                 return;
@@ -516,6 +991,11 @@ export class ReplSession {
             case 'agent.blocked': {
                 const target = this.state.agents.find((a) => a.taskId === event.taskId);
                 this.lastStepDetail.delete(event.taskId);
+                if (this.askBufferPending.has(event.taskId)) {
+                    this.appendSystemLine('Persona emitted incomplete <pugi-ask> or <pugi-plan-review> tag; dropped.');
+                }
+                this.askBuffer.delete(event.taskId);
+                this.askBufferPending.delete(event.taskId);
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
                         ? { ...a, status: 'blocked', detail: event.detail }
@@ -529,6 +1009,11 @@ export class ReplSession {
             case 'agent.failed': {
                 const target = this.state.agents.find((a) => a.taskId === event.taskId);
                 this.lastStepDetail.delete(event.taskId);
+                if (this.askBufferPending.has(event.taskId)) {
+                    this.appendSystemLine('Persona emitted incomplete <pugi-ask> or <pugi-plan-review> tag; dropped.');
+                }
+                this.askBuffer.delete(event.taskId);
+                this.askBufferPending.delete(event.taskId);
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
                         ? { ...a, status: 'failed', detail: event.error }
@@ -542,6 +1027,39 @@ export class ReplSession {
         }
     }
     /* ------------- transcript helpers -------------- */
+    /**
+     * Look up the persona slug for a running task. Used by the tool call
+     * synthesiser to colour the tool stream rows correctly. Falls back to
+     * the literal `unknown` slug when the task is not in the agent tree
+     * (the SSE wire can emit a step before the matching spawn under heavy
+     * load - rare in practice but the pane stays robust).
+     */
+    personaSlugForTask(taskId) {
+        const agent = this.state.agents.find((a) => a.taskId === taskId);
+        return agent?.personaSlug ?? 'unknown';
+    }
+    /**
+     * Fold a tool call entry into the rolling list. If the entry id
+     * already exists, replace it in-place (so a synthesised `running` →
+     * `ok` transition reuses the same row). Otherwise append. The list
+     * is capped at `MAX_TOOL_CALLS` so a long-running session does not
+     * leak memory.
+     */
+    appendToolCall(entry) {
+        const existingIndex = this.state.toolCalls.findIndex((c) => c.id === entry.id);
+        let next;
+        if (existingIndex >= 0) {
+            next = this.state.toolCalls.slice();
+            next[existingIndex] = entry;
+        }
+        else {
+            next = this.state.toolCalls.concat(entry);
+        }
+        if (next.length > MAX_TOOL_CALLS) {
+            next = next.slice(-MAX_TOOL_CALLS);
+        }
+        this.patch({ toolCalls: next });
+    }
     appendOperatorLine(text) {
         this.appendRow({ source: 'operator', text });
     }
@@ -549,7 +1067,19 @@ export class ReplSession {
         this.appendRow({ source: 'system', text });
     }
     appendPersonaLine(personaSlug, text) {
-        this.appendRow({ source: 'persona', text, personaSlug });
+        // α6.14.2 wave 5: dedup the persona display-name prefix. The
+        // conversation pane already renders `▸ <DisplayName> <text>` from
+        // the slug → name map; when the model's own reply begins with
+        // the same display name (CEO 2026-05-25 screenshot: "Pugi Pugi,
+        // координатор Pugi"), the operator sees the name twice. Strip
+        // the leading display-name token (with optional trailing comma /
+        // colon / whitespace) so the prefix the pane adds is the only one
+        // visible. We also drop any leaked `<workspace-context-NONCE>`
+        // wrapper the model sometimes echoes back at the head of its
+        // first turn — that envelope is for prompt scaffolding, not for
+        // the operator's eyes.
+        const stripped = stripPersonaPrefixEcho(personaSlug, text);
+        this.appendRow({ source: 'persona', text: stripped, personaSlug });
     }
     appendRow(input) {
         if (input.text.length === 0)
@@ -563,6 +1093,161 @@ export class ReplSession {
         };
         const next = this.state.transcript.concat(row).slice(-MAX_TRANSCRIPT_ROWS);
         this.patch({ transcript: next });
+        // Mirror into the local SessionStore so `/resume` can replay.
+        // Persistence is fail-safe: a single error becomes one system
+        // line, subsequent errors are silent so a stuck disk does not
+        // flood the operator. The mapping from row.source -> store kind:
+        //   operator -> 'user'   (drives turn_count + title)
+        //   persona  -> 'persona'
+        //   system   -> 'system'
+        this.persistRow(row);
+    }
+    /**
+     * Best-effort write of one transcript row into the local
+     * SessionStore. Swallows errors after emitting one system line so a
+     * broken store never blocks the conversation. Public callers go
+     * through `appendRow` — this method is private on purpose.
+     */
+    persistRow(row) {
+        if (!this.store)
+            return;
+        const kind = row.source === 'operator' ? 'user'
+            : row.source === 'persona' ? 'persona'
+                : 'system';
+        const payload = row.source === 'persona'
+            ? { text: row.text, personaSlug: row.personaSlug }
+            : row.source === 'operator'
+                ? { brief: row.text }
+                : { text: row.text };
+        const event = { t: row.timestampEpochMs, kind, payload };
+        void this.store.appendEvent(event).catch((error) => {
+            if (this.storeErrorEmitted)
+                return;
+            this.storeErrorEmitted = true;
+            const msg = error instanceof Error ? error.message : String(error);
+            // Use appendRow directly via state patch so we don't recurse
+            // into persistRow (which would loop on a stuck store).
+            const errRow = {
+                id: randomUUID(),
+                source: 'system',
+                text: `Local session persistence failed: ${msg}. Conversation continues in-memory only.`,
+                timestampEpochMs: this.now(),
+            };
+            const next = this.state.transcript.concat(errRow).slice(-MAX_TRANSCRIPT_ROWS);
+            this.patch({ transcript: next });
+        });
+    }
+    /**
+     * Restore a transcript from a stored event log — α6.4. Called by
+     * the CLI bootstrap when the operator runs `pugi resume <id>` or
+     * picks an entry from the `/resume` picker. Replays each event into
+     * the local transcript WITHOUT writing back to the store so the
+     * restore is idempotent.
+     *
+     * Implementation note: we briefly disable persistence by setting
+     * `storeErrorEmitted` BEFORE the replay and clearing it after — but
+     * the cleaner path is to bypass `appendRow` entirely and patch
+     * state directly. We do the latter so persistRow does not double-
+     * write the restored events.
+     */
+    restoreTranscript(events) {
+        const rows = [];
+        for (const event of events) {
+            const row = eventToTranscriptRow(event);
+            if (row)
+                rows.push(row);
+        }
+        // Cap at MAX_TRANSCRIPT_ROWS — the same cap appendRow uses so the
+        // window math stays consistent post-restore.
+        const capped = rows.slice(-MAX_TRANSCRIPT_ROWS);
+        this.patch({ transcript: capped });
+    }
+    /**
+     * Local session id used as the persistence key. Surfaced to the
+     * CLI bootstrap so `pugi resume` listings can pin the id without
+     * pulling it out of internal state.
+     */
+    getLocalSessionId() {
+        return this.localSessionId;
+    }
+    /* ------------- α6.3 buffered tag detection -------------- */
+    /**
+     * Scan the running `agent.step.detail` buffer for `<pugi-ask>` /
+     * `<pugi-plan-review>` envelopes. If a complete envelope is found,
+     * the parser strips it from the visible body and sets the matching
+     * `pendingAsk` / `pendingPlanReview` state so the REPL can render
+     * the modal. Streaming partial tags (open observed, close not yet
+     * arrived) are kept in the buffer so the next step event can extend
+     * them.
+     *
+     * Returns the sanitised body the caller should treat as the
+     * persona's prose. May be empty when the entire body was tag XML;
+     * the caller then leaves `lastStepDetail` untouched and the
+     * `agent.completed` fallback ("shipped.") fires.
+     */
+    consumeAskAndPlanReviewTags(taskId, detail) {
+        if (!detail || detail.length === 0) {
+            return this.askBuffer.get(taskId) ?? '';
+        }
+        // The persona emits the running detail as a cumulative string, so
+        // a fresh `agent.step` carries the full body up to the current
+        // token (matches the wave-2 caching contract above). We pass the
+        // raw detail through the extractors directly rather than keeping a
+        // separate buffer — but we still record the pre-extraction body so
+        // a partial open tag is preserved when the next chunk arrives.
+        this.askBuffer.set(taskId, detail);
+        const askResult = extractAskTags(detail);
+        let working = askResult.cleaned;
+        for (const tag of askResult.tags) {
+            if (this.seenTagSignatures.includes(tag.signature))
+                continue;
+            this.recordSeenTag(tag.signature);
+            // Only one pending ask at a time — drop additional tags in the
+            // same step into the cleaned body as a system warning. The
+            // persona's prompt forbids concurrent asks, so this branch is a
+            // defensive guard against a misbehaving model.
+            if (this.state.pendingAsk) {
+                this.appendSystemLine('Persona emitted a second <pugi-ask> while one was already open. Dropped.');
+                continue;
+            }
+            this.patch({ pendingAsk: tag, pendingAskSource: 'persona' });
+        }
+        if (askResult.hadMalformedTag) {
+            this.appendSystemLine('Malformed <pugi-ask> dropped (parser refusal).');
+        }
+        const planResult = extractPlanReviewTags(working);
+        working = planResult.cleaned;
+        for (const tag of planResult.tags) {
+            if (this.seenTagSignatures.includes(tag.signature))
+                continue;
+            this.recordSeenTag(tag.signature);
+            if (this.state.pendingPlanReview) {
+                this.appendSystemLine('Persona emitted a second <pugi-plan-review> while one was already open. Dropped.');
+                continue;
+            }
+            this.patch({ pendingPlanReview: tag, pendingPlanReviewSource: 'persona' });
+        }
+        if (planResult.hadMalformedTag) {
+            this.appendSystemLine('Malformed <pugi-plan-review> dropped (parser refusal).');
+        }
+        // Record / clear the "pending open tag" flag so agent.completed can
+        // emit a warning if the persona ends the turn with an unfinished
+        // envelope. The flag flips OFF when both parsers report no
+        // outstanding open tag - if either is still pending, we keep it on
+        // so the warning fires once at turn end.
+        if (askResult.pendingOpenTag || planResult.pendingOpenTag) {
+            this.askBufferPending.add(taskId);
+        }
+        else {
+            this.askBufferPending.delete(taskId);
+        }
+        return working;
+    }
+    recordSeenTag(signature) {
+        this.seenTagSignatures.push(signature);
+        while (this.seenTagSignatures.length > 32) {
+            this.seenTagSignatures.shift();
+        }
     }
     /* ------------- agent count + clock -------------- */
     activeAgentCount() {
@@ -599,6 +1284,89 @@ export class ReplSession {
  * does not recognise, the REPL still renders something usable rather
  * than crashing mid-frame.
  */
+/**
+ * Map a stored SessionEvent back into a TranscriptRow for `/resume`
+ * replay. Returns null when the event has no operator-visible body
+ * (e.g. tool.start without a text payload — those land back as
+ * tool stream rows, not transcript rows). The shape mirrors the
+ * `persistRow` mapping in reverse:
+ *
+ *   'user'    -> operator (brief)
+ *   'persona' -> persona  (text + personaSlug)
+ *   'system'  -> system   (text)
+ *
+ * Exported indirectly via `restoreTranscript`.
+ */
+function eventToTranscriptRow(event) {
+    const payload = (event.payload ?? null);
+    if (event.kind === 'user') {
+        const text = typeof payload?.brief === 'string'
+            ? payload.brief
+            : typeof payload?.text === 'string'
+                ? payload.text
+                : '';
+        if (text.length === 0)
+            return null;
+        return {
+            id: randomUUID(),
+            source: 'operator',
+            text,
+            timestampEpochMs: event.t,
+        };
+    }
+    if (event.kind === 'persona') {
+        const text = typeof payload?.text === 'string' ? payload.text : '';
+        if (text.length === 0)
+            return null;
+        const personaSlug = typeof payload?.personaSlug === 'string'
+            ? payload.personaSlug
+            : undefined;
+        return {
+            id: randomUUID(),
+            source: 'persona',
+            text,
+            personaSlug,
+            timestampEpochMs: event.t,
+        };
+    }
+    if (event.kind === 'system') {
+        const text = typeof payload?.text === 'string' ? payload.text : '';
+        if (text.length === 0)
+            return null;
+        return {
+            id: randomUUID(),
+            source: 'system',
+            text,
+            timestampEpochMs: event.t,
+        };
+    }
+    return null;
+}
+/**
+ * Heuristic: does this text contain Markdown structures that benefit
+ * from atomic grouping? Code fences, bullet lists, numbered lists,
+ * headings — anything where per-line splitting would fragment visual
+ * grouping (Claude triple-review P1 PR #369).
+ */
+function looksLikeMarkdown(text) {
+    if (text.includes('```'))
+        return true;
+    const lines = text.split('\n');
+    let bulletCount = 0;
+    let numberedCount = 0;
+    let headingCount = 0;
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (/^[-*+]\s+\S/.test(line))
+            bulletCount += 1;
+        if (/^\d+\.\s+\S/.test(line))
+            numberedCount += 1;
+        if (/^#{1,6}\s+\S/.test(line))
+            headingCount += 1;
+    }
+    // 2+ bullets OR 2+ numbered OR any heading = group atomically.
+    return bulletCount >= 2 || numberedCount >= 2 || headingCount >= 1;
+}
 function safePersonaName(role) {
     try {
         return getPersonaForRole(role).name;
@@ -615,4 +1383,305 @@ function safePersonaName(role) {
 export function knownRoles() {
     return listRoles();
 }
+/* ------------------------------------------------------------------ */
+/* Tool call synthesiser - α6.12                                      */
+/* ------------------------------------------------------------------ */
+/**
+ * Match canonical tool invocation grammar in an `agent.step.detail`
+ * string and emit a synthesised `ToolCallEntry`. Returns null when no
+ * known tool pattern matches.
+ *
+ * The grammar mirrors the way Claude Code, Codex CLI, and Gemini CLI
+ * display tool calls in their tool stream panes:
+ *
+ *   Read(path)
+ *   Edit(path[:lines])
+ *   Bash(command)
+ *   Grep("pattern" [in path])
+ *   Glob(pattern)
+ *   WebFetch(url)
+ *
+ * The matcher is case-insensitive on the tool name so a persona that
+ * spells the tool as `READ(...)` or `web_fetch(...)` still lands in
+ * the pane. Args are capped at 80 characters; the pane will further
+ * truncate to 60 on render so the row stays single-line on a narrow
+ * terminal.
+ *
+ * Exported for unit testing - production code path is internal.
+ */
+export function synthesiseToolCall(input) {
+    const detail = input.detail.trim();
+    if (detail.length === 0)
+        return null;
+    // Pattern: ToolName(args) optionally suffixed with a result hint.
+    // We allow the canonical Claude Code casing AND the snake_case
+    // alias `web_fetch` so the synthesiser matches what personas write.
+    const match = /^(Read|Edit|Bash|Grep|Glob|WebFetch|web_fetch)\s*\(\s*([^)]*)\s*\)\s*(.*)$/i
+        .exec(detail);
+    if (!match)
+        return null;
+    const toolName = normaliseToolName(match[1]);
+    const args = (match[2] ?? '').trim().slice(0, 80);
+    const tail = (match[3] ?? '').trim();
+    const status = parseStatusFromTail(tail);
+    return {
+        id: `${input.taskId}:${toolName}:${args}`,
+        agent: input.agent,
+        tool: toolName,
+        args,
+        status: status.status,
+        detail: status.detail,
+        startedAtEpochMs: input.now,
+    };
+}
+function normaliseToolName(raw) {
+    const lower = raw.toLowerCase();
+    if (lower === 'webfetch' || lower === 'web_fetch')
+        return 'web_fetch';
+    if (lower === 'read')
+        return 'read';
+    if (lower === 'edit')
+        return 'edit';
+    if (lower === 'bash')
+        return 'bash';
+    if (lower === 'grep')
+        return 'grep';
+    if (lower === 'glob')
+        return 'glob';
+    // Unreachable - regex constrains the input. Fallback keeps types happy.
+    return 'read';
+}
+/**
+ * Cheap status inference from the tail string. We honour explicit
+ * `OK` / `error` / `running` prefixes the dispatcher may write, plus
+ * a `+/-` diff hint (treated as `ok`) and a `no match` (treated as
+ * `ok` because grep with no result is not an error condition).
+ */
+function parseStatusFromTail(tail) {
+    if (tail.length === 0)
+        return { status: 'running' };
+    const lower = tail.toLowerCase();
+    if (lower.startsWith('error') || lower.startsWith('failed')) {
+        return { status: 'error', detail: tail };
+    }
+    if (lower.startsWith('running')) {
+        return { status: 'running', detail: tail };
+    }
+    return { status: 'ok', detail: tail };
+}
+/* ------------------------------------------------------------------ */
+/* α6.3 office-hours encoders                                          */
+/*                                                                    */
+/* Mirrors `tui/ask-modal.tsx#encodeAskVerdict` so the session can     */
+/* synthesise the operator-side echo without dragging an Ink module    */
+/* into the test surface. The two encoders MUST agree byte-for-byte —  */
+/* a divergence would silently mis-prefix the persona's follow-up.    */
+/* ------------------------------------------------------------------ */
+function encodeAskVerdictLocal(verdict) {
+    if (verdict.cancelled)
+        return '[ASK-RESPONSE:cancelled]';
+    if (verdict.value.length > 0)
+        return `[ASK-RESPONSE:${verdict.value}]`;
+    if (verdict.customInput && verdict.customInput.length > 0) {
+        return `[ASK-RESPONSE:other] ${verdict.customInput}`;
+    }
+    return '[ASK-RESPONSE:cancelled]';
+}
+/**
+ * Strip any leading `[ASK-RESPONSE:...]` or `[PLAN-VERDICT:...]`
+ * pattern from free-text operator input so a malicious or accidental
+ * operator string cannot forge a verdict header. Stripping iterates
+ * because the operator could prepend several forged headers in a row;
+ * we keep peeling until the head is clean.
+ *
+ * Example: operator types `[ASK-RESPONSE:vercel] my real answer` -
+ * the leading `[ASK-RESPONSE:vercel] ` is stripped, leaving
+ * `my real answer`, so the encoded wire string becomes
+ * `[ASK-RESPONSE:other] my real answer` rather than
+ * `[ASK-RESPONSE:other] [ASK-RESPONSE:vercel] my real answer` which
+ * a prefix-greedy persona could read as "operator chose vercel".
+ *
+ * Claude triple-review P1 (PR #375).
+ */
+function sanitiseVerdictText(raw) {
+    let cleaned = raw;
+    // Bounded loop: each iteration must strip a non-empty pattern, so it
+    // terminates in O(input length). Hard cap as defence-in-depth in case
+    // the regex ever matches an empty span.
+    for (let i = 0; i < raw.length + 4; i += 1) {
+        const stripped = cleaned.replace(/^\s*\[(?:ASK-RESPONSE|PLAN-VERDICT):[^\]]*\]\s*/u, '');
+        if (stripped === cleaned)
+            break;
+        cleaned = stripped;
+    }
+    return cleaned.trim();
+}
+function sanitiseAskVerdict(verdict) {
+    if (verdict.customInput === undefined)
+        return verdict;
+    const sanitisedCustom = sanitiseVerdictText(verdict.customInput);
+    if (sanitisedCustom === verdict.customInput)
+        return verdict;
+    // If sanitisation emptied the buffer, treat the verdict as a
+    // cancellation rather than dispatching a meaningless "other" with no
+    // body. Preserves the dispatch invariant (no empty bodies) and
+    // matches the encoder's fallback.
+    if (sanitisedCustom.length === 0) {
+        return { value: '', cancelled: true };
+    }
+    return { ...verdict, customInput: sanitisedCustom };
+}
+function sanitisePlanReviewResult(result) {
+    if (result.verdict !== 'modify')
+        return result;
+    if (result.modifyText === undefined)
+        return result;
+    const sanitisedText = sanitiseVerdictText(result.modifyText);
+    if (sanitisedText === result.modifyText)
+        return result;
+    if (sanitisedText.length === 0) {
+        return { verdict: 'cancel' };
+    }
+    return { verdict: 'modify', modifyText: sanitisedText };
+}
+function encodePlanReviewVerdictLocal(result) {
+    switch (result.verdict) {
+        case 'approve':
+            return '[PLAN-VERDICT:approve]';
+        case 'cancel':
+            return '[PLAN-VERDICT:cancel]';
+        case 'modify':
+            if (result.modifyText && result.modifyText.length > 0) {
+                return `[PLAN-VERDICT:modify] ${result.modifyText}`;
+            }
+            return '[PLAN-VERDICT:cancel]';
+    }
+}
+/**
+ * Compose the human-readable transcript line that records the
+ * operator's ask verdict. Mirrors Codex CLI's "you chose: <label>"
+ * pattern so the conversation reads linearly.
+ */
+function humanLabelForVerdict(tag, verdict) {
+    if (verdict.cancelled)
+        return '(cancelled the question)';
+    if (verdict.value.length > 0) {
+        const opt = tag.options.find((o) => o.value === verdict.value);
+        return opt ? `chose: ${opt.label}` : `chose: ${verdict.value}`;
+    }
+    if (verdict.customInput && verdict.customInput.length > 0) {
+        return `chose: other - ${verdict.customInput}`;
+    }
+    return '(cancelled the question)';
+}
+function humanLabelForPlanReviewVerdict(result) {
+    switch (result.verdict) {
+        case 'approve':
+            return 'approved the plan';
+        case 'cancel':
+            return 'cancelled the plan';
+        case 'modify':
+            if (result.modifyText && result.modifyText.length > 0) {
+                return `modified the plan: ${result.modifyText}`;
+            }
+            return 'cancelled the plan';
+    }
+}
+/**
+ * Synthesise a 2-option yes/no `<pugi-ask>` tag from a raw question
+ * string. Used by the `/ask` slash command and by `pugi ask <question>`
+ * to give the operator a manual entrypoint into the office-hours UI
+ * without needing a persona-side emission.
+ *
+ * Returns null when the question fails the parser's length cap so the
+ * caller can surface a clear error rather than crashing the modal.
+ */
+export function synthesiseLocalAskTag(question) {
+    const trimmed = question.trim();
+    if (trimmed.length === 0 || trimmed.length > 80)
+        return null;
+    const options = [
+        { value: 'yes', label: 'Yes' },
+        { value: 'no', label: 'No' },
+    ];
+    // Use the single-source signature helper so a persona-emitted ask
+    // with the same question + same option values does not collide with
+    // this synthesised one under a divergent algorithm. Claude
+    // triple-review P1 (PR #375).
+    const signature = signatureForAsk(trimmed, options);
+    return {
+        question: trimmed,
+        options,
+        signature,
+        start: 0,
+        end: 0,
+    };
+}
+/**
+ * Strip the persona's own display name from the head of a streamed
+ * reply, plus any leaked `<workspace-context-...>` envelope the model
+ * may echo on its first turn. Exported for direct unit testing —
+ * production callers go through `appendPersonaLine`.
+ *
+ * Examples (display name = "Pugi"):
+ *   "Pugi, координатор Pugi. Брифую..."   -> "координатор Pugi. Брифую..."
+ *   "Pugi: вот результат"                 -> "вот результат"
+ *   "<workspace-context-abc>Pugi, привет" -> "привет"
+ *   "обычный ответ без префикса"          -> "обычный ответ без префикса"
+ *
+ * The strip is conservative — we only remove the display name when it
+ * is followed by a separator (comma, colon, dash, space) so a sentence
+ * that legitimately contains the name mid-text ("спроси у Pugi") is
+ * not mangled. (α6.14.2 wave 5 — CEO dogfood fix.)
+ */
+export function stripPersonaPrefixEcho(personaSlug, text) {
+    let working = text.trimStart();
+    // Drop any leaked `<workspace-context-...>` / `</workspace-context-...>`
+    // wrapper at the head. The Mira prompt v1.1 sometimes echoes the
+    // scaffolding envelope back when the model is warm-starting the
+    // first turn; cosmetic noise the operator never needs to see.
+    // We strip both opening tag and any text up to (and including) the
+    // matching closing tag if present, else just the opening tag.
+    const openMatch = /^<workspace-context[^>]*>/i.exec(working);
+    if (openMatch) {
+        working = working.slice(openMatch[0].length).trimStart();
+        const closeMatch = /^([\s\S]*?)<\/workspace-context[^>]*>/i.exec(working);
+        if (closeMatch) {
+            working = working.slice(closeMatch[0].length).trimStart();
+        }
+    }
+    // Resolve the display name from the canonical roster. Unknown slugs
+    // (forward-compat with future personas streamed by a newer server)
+    // skip the strip — better to leave the text alone than to mis-strip.
+    const persona = getPersona(personaSlug);
+    if (!persona)
+        return working;
+    const display = persona.name;
+    if (!display || display.length === 0)
+        return working;
+    // Match `<DisplayName>` followed by an end-of-string, or by a
+    // separator (comma, colon, dash, period followed by space, single
+    // space). The match is case-insensitive so "pugi" also strips.
+    // Escape regex specials in the display name even though THE_TEN
+    // names are alpha-only today (forward-defense).
+    const escaped = display.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`^${escaped}(?:[\\s,:;\\-—–]+|$)`, 'i');
+    // Loop the strip so cascading echoes ("Pugi Pugi Pugi, координатор ...")
+    // collapse to a single name. The model occasionally emits the display
+    // name two or three times back-to-back when the pane prefix also
+    // injects "▸ Pugi"; without the loop, only the first token would be
+    // peeled and the operator would still see "▸ Pugi Pugi, координатор".
+    // Cap at 3 iterations — beyond that the text is either pathological
+    // or unrelated and we should not keep chewing it. Bail when an
+    // iteration makes no progress to avoid infinite loops on a regex that
+    // matches an empty string (defence-in-depth even though the current
+    // pattern guarantees at least one consumed char).
+    for (let i = 0; i < 3; i += 1) {
+        const m = re.exec(working);
+        if (!m || m[0].length === 0)
+            break;
+        working = working.slice(m[0].length).trimStart();
+    }
+    return working;
+}
 //# sourceMappingURL=session.js.map