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

package/dist/tui/ask-user-question-chips.js

@@ -0,0 +1,257 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * AskUserQuestionChips — multi-question short-format chip renderer
+ * for the structured AskUserQuestion tool (PUGI-480).
+ *
+ * Renders up to 3 question chips side-by-side, each with up to ~5 short
+ * (≤ 5-word) option labels. Replaces paragraph-wall prompts с a compact
+ * keyboard-driven picker:
+ *
+ *   Pugi: 2 quick choices
+ *    ┌────────────────────────┐
+ *    │ Stack                  │
+ *    │ ▸ 1 Browser JS         │
+ *    │   2 React              │
+ *    │   3 Other...           │
+ *    └────────────────────────┘
+ *    ┌────────────────────────┐
+ *    │ Size                   │
+ *    │ ▸ 1 9x9 (classic)      │
+ *    │   2 16x16              │
+ *    │   3 Custom             │
+ *    └────────────────────────┘
+ *    [Enter] use highlighted defaults  ·  [↑↓] navigate  ·  [s] skip
+ *
+ * Contract:
+ *  - questions[].options[].label MUST be ≤ 5 words (renderer truncates
+ *    overflow с ellipsis defensively; the schema validator rejects at
+ *    the tool entry point so the model never produces overflow legally).
+ *  - First option of each question is pre-highlighted (default).
+ *  - Enter без movement applies defaults across ALL questions.
+ *  - 1-9 jump к the matching option in the focused question.
+ *  - ↑↓ navigate within the focused question.
+ *  - ←→ (and Tab/Shift-Tab) move between questions.
+ *  - [s] skips the focused question (uses its default) and advances to
+ *    the next; [s] on the last question commits.
+ *  - [Esc] cancels the entire dialog (user_cancelled).
+ *
+ * Non-TTY fallback: when the `forceFallback` prop is true, renders a
+ * static numbered text list and does NOT mount the Ink useInput hook.
+ * The component itself does NOT sniff `process.stdin.isTTY` — that gate
+ * lives in the upstream REPL wiring, which either mounts this chip
+ * component (TTY path) or emits the legacy `[user_input_required]`
+ * envelope (non-TTY path). Keeping the gate в the caller keeps the
+ * component testable under ink-testing-library (which mocks stdin but
+ * не sets isTTY).
+ *
+ * Brand voice gate: ASCII glyphs only, zero attribution to external AIs,
+ * no em-dashes. Power-word neutral so localised variants land cleanly.
+ */
+import { useMemo, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+/**
+ * Hard truncation cap. The schema validator enforces ≤ 5 words per
+ * label, but the renderer still defends in depth: a malicious or
+ * legacy payload with a 14-word label MUST not blow the chip width.
+ */
+export const ASK_CHIPS_LABEL_WORD_CAP = 5;
+export const ASK_CHIPS_LABEL_CHAR_CAP = 22;
+export const ASK_CHIPS_QUESTION_CAP = 3;
+export const ASK_CHIPS_SKIP_LABEL = 'Skip — use defaults';
+/**
+ * Truncate a label к the configured word / character caps. Always
+ * append "…" when truncation happens so the operator knows the chip
+ * is hiding content.
+ */
+export function truncateLabel(raw) {
+    const trimmed = raw.trim().replace(/\s+/gu, ' ');
+    // Word cap (whitespace-delimited). 5-word rule is the canonical limit.
+    const words = trimmed.split(' ');
+    let candidate = trimmed;
+    if (words.length > ASK_CHIPS_LABEL_WORD_CAP) {
+        candidate = `${words.slice(0, ASK_CHIPS_LABEL_WORD_CAP).join(' ')}…`;
+    }
+    // Char cap (defense-in-depth — protects chip width even с short-word
+    // payloads like "AAAAAAAAAAAAAAAAAAAAA" that pass the word gate).
+    if (candidate.length > ASK_CHIPS_LABEL_CHAR_CAP) {
+        candidate = `${candidate.slice(0, ASK_CHIPS_LABEL_CHAR_CAP - 1)}…`;
+    }
+    return candidate;
+}
+/**
+ * The component renders в interactive mode by default. The non-TTY
+ * gate is the caller's responsibility — see ask-user-question-chips.tsx
+ * header docs. Production REPL wiring should check `process.stdin.isTTY`
+ * upstream и pass `forceFallback={true}` when stdin is not a TTY, OR
+ * skip mounting the chip component entirely и emit the legacy
+ * `[user_input_required]` envelope.
+ */
+function shouldUseFallback(forceFallback) {
+    return forceFallback === true;
+}
+/**
+ * Build the default selections vector (all first options) so Enter
+ * без movement applies a coherent set, and so non-TTY fallback can
+ * commit immediately.
+ */
+function buildDefaults(questions) {
+    return questions.map((q) => {
+        const first = q.options[0];
+        return {
+            header: q.header,
+            pickedIndex: 0,
+            pickedLabel: first ? truncateLabel(first.label) : '',
+            skipped: false,
+        };
+    });
+}
+export function AskUserQuestionChips(props) {
+    const useFallback = shouldUseFallback(props.forceFallback);
+    // Defensive cap: never render more than ASK_CHIPS_QUESTION_CAP chips.
+    // Schema enforces this at the tool boundary; the renderer still trims
+    // в case a legacy / malicious payload sneaks through.
+    const questions = useMemo(() => props.questions.slice(0, ASK_CHIPS_QUESTION_CAP), [props.questions]);
+    // Cursor state: which question is focused, and which option within
+    // each question is highlighted. Initialised к first option (default).
+    const [focusedQuestion, setFocusedQuestion] = useState(0);
+    const [cursorPerQuestion, setCursorPerQuestion] = useState(() => questions.map(() => 0));
+    // Per-question explicit skip flag. Skipped questions still emit their
+    // default index, but flagged `skipped: true` so downstream can audit.
+    const [skipped, setSkipped] = useState(() => questions.map(() => false));
+    function commit(skipMask = skipped) {
+        const selections = questions.map((q, qIdx) => {
+            const optionIdx = cursorPerQuestion[qIdx] ?? 0;
+            const opt = q.options[optionIdx] ?? q.options[0];
+            return {
+                header: q.header,
+                pickedIndex: optionIdx,
+                pickedLabel: opt ? truncateLabel(opt.label) : '',
+                skipped: skipMask[qIdx] === true,
+            };
+        });
+        props.onResolve({ selections, cancelled: false });
+    }
+    function cancel() {
+        props.onResolve({ selections: buildDefaults(questions), cancelled: true });
+    }
+    useInput((input, key) => {
+        // Esc cancels the entire AskUserQuestion (user_cancelled).
+        if (key.escape) {
+            cancel();
+            return;
+        }
+        // Enter commits the current selection (applies defaults across
+        // any questions the operator did not touch).
+        if (key.return) {
+            commit();
+            return;
+        }
+        // [s] skips the focused question (uses default), advances to next.
+        // [s] on the LAST question commits the whole set.
+        if (input === 's' || input === 'S') {
+            const nextSkipped = skipped.slice();
+            nextSkipped[focusedQuestion] = true;
+            if (focusedQuestion >= questions.length - 1) {
+                setSkipped(nextSkipped);
+                commit(nextSkipped);
+                return;
+            }
+            setSkipped(nextSkipped);
+            setFocusedQuestion((q) => Math.min(q + 1, questions.length - 1));
+            return;
+        }
+        // ↑/↓ navigate within the focused question.
+        if (key.upArrow) {
+            setCursorPerQuestion((prev) => {
+                const next = prev.slice();
+                const opts = questions[focusedQuestion]?.options ?? [];
+                const len = opts.length;
+                if (len === 0)
+                    return prev;
+                const cur = next[focusedQuestion] ?? 0;
+                next[focusedQuestion] = (cur - 1 + len) % len;
+                return next;
+            });
+            return;
+        }
+        if (key.downArrow) {
+            setCursorPerQuestion((prev) => {
+                const next = prev.slice();
+                const opts = questions[focusedQuestion]?.options ?? [];
+                const len = opts.length;
+                if (len === 0)
+                    return prev;
+                const cur = next[focusedQuestion] ?? 0;
+                next[focusedQuestion] = (cur + 1) % len;
+                return next;
+            });
+            return;
+        }
+        // ←/→ (or Tab/Shift-Tab) navigate between questions.
+        if (key.leftArrow || (key.shift && key.tab)) {
+            setFocusedQuestion((q) => (q - 1 + questions.length) % questions.length);
+            return;
+        }
+        if (key.rightArrow || key.tab) {
+            setFocusedQuestion((q) => (q + 1) % questions.length);
+            return;
+        }
+        // 1-9 jumps к the matching option in the focused question.
+        const numeric = Number.parseInt(input, 10);
+        if (!Number.isNaN(numeric) && numeric >= 1 && numeric <= 9) {
+            const opts = questions[focusedQuestion]?.options ?? [];
+            const target = numeric - 1;
+            if (target >= 0 && target < opts.length) {
+                setCursorPerQuestion((prev) => {
+                    const next = prev.slice();
+                    next[focusedQuestion] = target;
+                    return next;
+                });
+            }
+            return;
+        }
+    }, { isActive: props.inert !== true && useFallback === false });
+    // ─── Non-TTY fallback ────────────────────────────────────────────────
+    // When stdin is not a TTY we still need to render SOMETHING — but
+    // we cannot drive keystrokes, so we emit a numbered text list per
+    // question and let the upstream envelope handler ask the operator.
+    if (useFallback) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsx(Text, { bold: true, children: `Pugi: ${questions.length} quick ${questions.length === 1 ? 'choice' : 'choices'}` }) }), questions.map((q, qIdx) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: `${q.header}` }), q.options.map((opt, oIdx) => (_jsx(Text, { children: `  ${oIdx + 1}. ${truncateLabel(opt.label)}${oIdx === 0 ? ' (default)' : ''}` }, `q-${qIdx}-o-${oIdx}`)))] }, `q-${qIdx}-${q.header}`))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, italic: true, children: `(non-interactive — defaults apply)` }) })] }));
+    }
+    // ─── Interactive Ink render ─────────────────────────────────────────
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsx(Text, { bold: true, children: `Pugi: ${questions.length} quick ${questions.length === 1 ? 'choice' : 'choices'}` }) }), _jsx(Box, { flexDirection: "row", marginTop: 1, children: questions.map((q, qIdx) => {
+                    const isFocused = qIdx === focusedQuestion;
+                    const cursor = cursorPerQuestion[qIdx] ?? 0;
+                    const isSkipped = skipped[qIdx] === true;
+                    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: isFocused ? 'cyan' : 'gray', paddingX: 1, marginRight: 1, minWidth: 24, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: isFocused ? 'cyan' : undefined, children: q.header }), isSkipped ? (_jsx(Text, { dimColor: true, italic: true, children: ' (skipped)' })) : null] }), q.options.map((opt, oIdx) => {
+                                const isHighlighted = isFocused && oIdx === cursor;
+                                const label = truncateLabel(opt.label);
+                                const isSkipOption = label === ASK_CHIPS_SKIP_LABEL ||
+                                    opt.label === ASK_CHIPS_SKIP_LABEL;
+                                return (_jsxs(Box, { children: [_jsx(Text, { color: isHighlighted ? 'cyan' : undefined, bold: isHighlighted, children: isHighlighted ? '▸ ' : '  ' }), _jsx(Text, { color: isHighlighted ? 'cyan' : undefined, children: `${oIdx + 1} ` }), isSkipOption ? (_jsx(Text, { dimColor: true, italic: true, children: label })) : (_jsx(Text, { bold: isHighlighted, children: label }))] }, `opt-${qIdx}-${oIdx}-${opt.label}`));
+                            })] }, `chip-${qIdx}-${q.header}`));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `[Enter] use highlighted defaults  ·  [↑↓] navigate  ·  [←→] switch  ·  [s] skip  ·  [Esc] cancel` }) })] }));
+}
+/**
+ * Encode the chip verdict into the persona-recognisable turn-injection
+ * string. Mirrors `encodeAskUserQuestionVerdict` from the single-question
+ * prompt so the model sees a consistent grammar.
+ *
+ * Examples:
+ *  - { cancelled: true } → "[ASK-USER-QUESTION:cancelled]"
+ *  - All defaults       → "[ASK-USER-QUESTION:answered] Stack=Browser JS; Size=9x9 (classic)"
+ *  - One skipped        → "[ASK-USER-QUESTION:answered] Stack=Browser JS; Size=(skipped: 9x9)"
+ */
+export function encodeAskUserQuestionChipsVerdict(result) {
+    if (result.cancelled)
+        return '[ASK-USER-QUESTION:cancelled]';
+    if (result.selections.length === 0)
+        return '[ASK-USER-QUESTION:cancelled]';
+    const parts = result.selections.map((sel) => {
+        if (sel.skipped)
+            return `${sel.header}=(skipped: ${sel.pickedLabel})`;
+        return `${sel.header}=${sel.pickedLabel}`;
+    });
+    return `[ASK-USER-QUESTION:answered] ${parts.join('; ')}`;
+}
+//# sourceMappingURL=ask-user-question-chips.js.map

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/dist/tui/welcome-data.js

@@ -9,12 +9,12 @@
  *
  *    ╭────── Pugi v0.1.0-beta.46 ──────╮
  *    │                                 │ Tips for getting started
- *    │     Welcome back Yurii!        │ Run /init to create PUGI.md...
+ *    │     Welcome back operator!        │ Run /init to create PUGI.md...
  *    │                                 │ ───────────
  *    │        ▗ ▗  ▖ ▖               │ What's new
  *    │          ▘▘ ▝▝                 │ * 0.1.0-beta.26 — RAG ...
  *    │ Sonnet 4.6 (1M context) · Founder
- *    │ yuriy.bulah@gmail.com · pugi-io Org
+ *    │ operator@gmail.com · pugi-io Org
  *    │ <workspace>
  *    ╰──────────────────────────────────╯
  *
@@ -79,8 +79,8 @@ function decodeJwtPayload(token) {
 /**
  * Derive a greeting first-name from an email's local part. The split
  * is intentionally aggressive: dot-separated, hyphen-separated, and
- * digit-stripped so `yuriy.bulah@gmail.com` resolves к "Yuriy" instead
- * of "yuriy.bulah". Title-cases the first segment. Falls back к
+ * digit-stripped so `operator@gmail.com` resolves к "operator" instead
+ * of "operator". Title-cases the first segment. Falls back к
  * "operator" when no email is available.
  *
  * Export so the spec can lock the heuristic against edge cases (numeric

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-beta.87",
+  "version": "0.1.0-beta.89",
   "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -63,7 +63,7 @@
     "which": "^6.0.0",
     "zod": "^3.23.0",
     "@pugi/personas": "0.1.2",
-    "@pugi/sdk": "0.1.0-beta.87"
+    "@pugi/sdk": "0.1.0-beta.89"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -87,6 +87,7 @@
     "doctor": "tsx src/index.ts doctor --json",
     "check:version-lockstep": "bash ../../scripts/check-version-lockstep.sh",
     "pack:smoke": "pnpm run check:version-lockstep && node scripts/pack-smoke.mjs",
-    "release-gate": "node scripts/secret-scanner.mjs"
+    "release-gate": "node scripts/secret-scanner.mjs",
+    "scan:tarball": "STAGE=$(mktemp -d) && npm pack --pack-destination \"$STAGE\" >/dev/null && bash ../../tools/scrub/scan-tarball.sh \"$STAGE\"/*.tgz; RC=$?; rm -rf \"$STAGE\"; exit $RC"
   }
 }

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"