@pugi/cli 0.1.0-beta.31 → 0.1.0-beta.35

package/dist/runtime/commands/redo.js

@@ -0,0 +1,361 @@
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { hashContent } from '../../core/file-cache.js';
+import { recordFileMutation, recordToolCall, recordToolResult, } from '../../core/session.js';
+import { deleteBlob, readBlob } from './redo-blob-store.js';
+/**
+ * `pugi redo` — counterpart to `pugi undo` (Wave 6, 2026-05-27).
+ *
+ * Reapplies the file mutations that the most recent `/undo` invocation
+ * reverted. Stack-based: each successful redo consumes one undo entry
+ * from the event log, so calling /redo twice after two /undo calls
+ * walks back through the original mutation history in reverse order.
+ *
+ * Walk strategy:
+ *   1. Read `.pugi/events.jsonl` line by line into an array.
+ *   2. Walk backwards. Find the most recent `tool_result` whose
+ *      `status === 'success'` and whose linked `tool_call` tool is
+ *      `undo` AND for which no later `tool_result` with tool `redo`
+ *      has already consumed it. (We track the consumed-by-redo set
+ *      by walking events forward once and tagging undo results that
+ *      a subsequent redo references.)
+ *   3. Gather every `file_mutation` event that shares the same undo
+ *      `toolCallId`. These are the INVERSE mutations:
+ *        - operation: 'delete' + beforeHash=<original-after-sha>
+ *          → original op was `create`; redo = recreate file from blob
+ *        - operation: 'update' + beforeHash=<original-after-sha>,
+ *          afterHash=<original-before-sha>
+ *          → original op was `update`; redo = restore content from blob
+ *        - operation: 'update' + beforeHash=undefined,
+ *          afterHash=<original-before-sha>
+ *          → original op was `delete`; redo = delete the file again
+ *
+ * Reapply strategy:
+ *   For each step we re-apply with a strict safety gate. If the file
+ *   was modified externally since the undo (current sha ≠ undo's
+ *   `afterHash`) we refuse to overwrite operator work and abort the
+ *   whole redo atomically — no partial reapply per spec parity with
+ *   the undo runner.
+ *
+ *   - inverse `delete` (recreate from create-undo): read blob keyed
+ *     by `beforeHash`, write at path. Path must not exist OR must
+ *     match the post-undo (afterHash = undefined, file deleted).
+ *   - inverse `update` with afterHash present (update-undo or
+ *     delete-undo restoring HEAD): file must currently match
+ *     `afterHash`. Reapply by writing blob content (update case) or
+ *     by unlinking the file (delete case — no blob exists, the
+ *     `beforeHash === undefined` discriminator routes here).
+ *   - any other shape → unsafe → abort.
+ *
+ * After a successful redo:
+ *   - Emit a `tool_call` event with tool `redo` and inputSummary
+ *     `replay <undo-toolCallId>` so the next /undo invocation walks
+ *     PAST it (the redo creates fresh mutations that show up as the
+ *     most recent successful mutating result).
+ *   - Emit one `file_mutation` per reapplied step describing the
+ *     re-applied operation (create / update / delete) so a subsequent
+ *     /undo can reverse the redo if the operator changes their mind.
+ *   - Best-effort delete the consumed blobs from `.pugi/undo-blobs/`
+ *     so a second /redo without a fresh /undo is a noop instead of
+ *     re-applying stale content.
+ */
+const UNDO_TOOL = 'undo';
+export async function runRedoCommand(_args, ctx) {
+    const eventsPath = resolve(ctx.workspaceRoot, '.pugi/events.jsonl');
+    if (!existsSync(eventsPath)) {
+        ctx.writeOutput({ command: 'redo', status: 'noop', reason: 'no_session' }, 'No session events found. Nothing to redo.');
+        return;
+    }
+    const events = parseEvents(eventsPath);
+    const target = findReplayTarget(events);
+    if (!target) {
+        ctx.writeOutput({ command: 'redo', status: 'noop', reason: 'no_undo' }, 'No /undo to redo. Run an undo first, then /redo will replay it.');
+        return;
+    }
+    if (target.mutations.length === 0) {
+        ctx.writeOutput({
+            command: 'redo',
+            status: 'noop',
+            reason: 'no_inverse_mutations',
+            undoToolCallId: target.undoToolCallId,
+        }, `Undo ${target.undoToolCallId} recorded no inverse mutations. Nothing to redo.`);
+        return;
+    }
+    // Pre-flight: every step must be reversible before touching disk.
+    const plan = planReplays(ctx.workspaceRoot, target.mutations);
+    if (plan.aborted) {
+        ctx.writeOutput({
+            command: 'redo',
+            status: 'aborted',
+            reason: plan.reason,
+            undoToolCallId: target.undoToolCallId,
+            unsafe: plan.unsafe,
+        }, `Refusing to redo ${target.undoToolCallId}: ${plan.reason}`);
+        process.exitCode = 1;
+        return;
+    }
+    const replayed = [];
+    for (const step of plan.steps) {
+        try {
+            executeReplay(ctx.workspaceRoot, step);
+            replayed.push({ path: step.path, operation: step.replayOperation });
+        }
+        catch (error) {
+            // Mid-flight failure after pre-flight said it was safe. Surface
+            // the error and bail — parity with the undo runner's "no partial
+            // state on failure" contract.
+            const message = error instanceof Error ? error.message : String(error);
+            ctx.writeOutput({
+                command: 'redo',
+                status: 'failed',
+                reason: message,
+                undoToolCallId: target.undoToolCallId,
+                replayed,
+                failedAt: step.path,
+            }, `Redo failed mid-flight on ${step.path}: ${message}`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // Audit the redo so a future /undo walks back through it. Each
+    // replayed step gets a fresh `file_mutation` event so the next
+    // /undo's walk picks this up as the most-recent successful
+    // mutating tool result.
+    const toolCallId = recordToolCall(ctx.session, 'redo', `replay ${target.undoToolCallId}`);
+    for (const step of plan.steps) {
+        recordFileMutation(ctx.session, {
+            toolCallId,
+            path: step.path,
+            operation: step.replayOperation,
+            beforeHash: step.preReplayHash,
+            afterHash: step.postReplayHash,
+        });
+    }
+    recordToolResult(ctx.session, toolCallId, 'success', `Redid ${replayed.length} mutation(s) from undo ${target.undoToolCallId}`);
+    // Best-effort blob cleanup. After redo the blob is no longer needed
+    // — a future /undo will capture fresh after-state from disk if the
+    // operator un-does this redo.
+    for (const step of plan.steps) {
+        if (step.blobSha)
+            deleteBlob(ctx.workspaceRoot, step.blobSha);
+    }
+    ctx.writeOutput({
+        command: 'redo',
+        status: 'ok',
+        undoToolCallId: target.undoToolCallId,
+        replayed,
+    }, [
+        `Redid ${replayed.length} mutation(s) from undo ${target.undoToolCallId}:`,
+        ...replayed.map((entry) => `  ${entry.operation.padEnd(7)} ${entry.path}`),
+        'Use /undo to revert.',
+    ].join('\n'));
+}
+function parseEvents(eventsPath) {
+    const raw = readFileSync(eventsPath, 'utf8');
+    const lines = raw.split('\n').filter((line) => line.trim().length > 0);
+    const out = [];
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                out.push(parsed);
+            }
+        }
+        catch {
+            // Partial-write tolerance — same approach as undo.ts.
+        }
+    }
+    return out;
+}
+/**
+ * Find the most recent successful `undo` tool result that has NOT
+ * been consumed by a later `redo` invocation.
+ *
+ * Consumption tracking: we collect every `redo` tool_call's
+ * `inputSummary` of the shape `replay <toolCallId>`. Any matching
+ * undo toolCallId is treated as already-redone — calling /redo a
+ * second time without a fresh /undo must be a noop, not a re-apply
+ * (re-apply would double-write the same content and corrupt the
+ * audit trail).
+ */
+function findReplayTarget(events) {
+    const toolCalls = new Map();
+    const results = [];
+    const consumed = new Set();
+    for (let i = 0; i < events.length; i += 1) {
+        const event = events[i];
+        if (!event)
+            continue;
+        if (event.type === 'tool_call' && typeof event.id === 'string' && typeof event.tool === 'string') {
+            toolCalls.set(event.id, { id: event.id, tool: event.tool, index: i });
+            if (event.tool === 'redo' && typeof event.inputSummary === 'string') {
+                const match = /^replay\s+(\S+)/.exec(event.inputSummary);
+                if (match && match[1])
+                    consumed.add(match[1]);
+            }
+        }
+        else if (event.type === 'tool_result' &&
+            typeof event.id === 'string' &&
+            typeof event.toolCallId === 'string' &&
+            (event.status === 'success' || event.status === 'error' || event.status === 'cancelled')) {
+            results.push({
+                id: event.id,
+                toolCallId: event.toolCallId,
+                status: event.status,
+                index: i,
+            });
+        }
+    }
+    // Newest → oldest walk so the stack pops in LIFO order.
+    for (let i = results.length - 1; i >= 0; i -= 1) {
+        const result = results[i];
+        if (result.status !== 'success')
+            continue;
+        const call = toolCalls.get(result.toolCallId);
+        if (!call)
+            continue;
+        if (call.tool !== UNDO_TOOL)
+            continue;
+        if (consumed.has(result.toolCallId))
+            continue;
+        const mutations = [];
+        for (const event of events) {
+            if (event.type !== 'file_mutation')
+                continue;
+            if (event.toolCallId !== result.toolCallId)
+                continue;
+            if (typeof event.path !== 'string')
+                continue;
+            if (event.operation !== 'create' &&
+                event.operation !== 'update' &&
+                event.operation !== 'delete' &&
+                event.operation !== 'move') {
+                continue;
+            }
+            mutations.push({
+                toolCallId: result.toolCallId,
+                path: event.path,
+                operation: event.operation,
+                beforeHash: typeof event.beforeHash === 'string' ? event.beforeHash : undefined,
+                afterHash: typeof event.afterHash === 'string' ? event.afterHash : undefined,
+            });
+        }
+        return { undoToolCallId: result.toolCallId, mutations };
+    }
+    return null;
+}
+function planReplays(root, mutations) {
+    const steps = [];
+    const unsafe = [];
+    for (const mutation of mutations) {
+        const abs = resolve(root, mutation.path);
+        // The undo emitted three inverse shapes — decode the original op
+        // from the (operation, beforeHash, afterHash) triple.
+        if (mutation.operation === 'delete' && mutation.beforeHash) {
+            // Original op was `create`. Redo = recreate from blob.
+            if (existsSync(abs)) {
+                unsafe.push(`${mutation.path}: post-undo expected file to be absent, found existing content`);
+                continue;
+            }
+            const content = readBlob(root, mutation.beforeHash);
+            if (content === undefined) {
+                unsafe.push(`${mutation.path}: no captured AFTER content blob (sha=${mutation.beforeHash.slice(0, 12)}…) — redo not available`);
+                continue;
+            }
+            if (hashContent(content) !== mutation.beforeHash) {
+                unsafe.push(`${mutation.path}: blob sha mismatch (store may have been tampered with) — refusing to write`);
+                continue;
+            }
+            steps.push({
+                path: mutation.path,
+                replayOperation: 'create',
+                preReplayHash: undefined,
+                postReplayHash: mutation.beforeHash,
+                content,
+                blobSha: mutation.beforeHash,
+            });
+            continue;
+        }
+        if (mutation.operation === 'update' && mutation.beforeHash && mutation.afterHash) {
+            // Original op was `update`. Post-undo file matches afterHash
+            // (= original beforeHash). Redo = restore beforeHash content
+            // from blob (= original afterHash content).
+            if (!existsSync(abs)) {
+                unsafe.push(`${mutation.path}: file expected to exist for update redo, not found`);
+                continue;
+            }
+            const current = readFileSync(abs, 'utf8');
+            if (hashContent(current) !== mutation.afterHash) {
+                unsafe.push(`${mutation.path}: modified externally since /undo — refusing to overwrite operator work`);
+                continue;
+            }
+            const content = readBlob(root, mutation.beforeHash);
+            if (content === undefined) {
+                unsafe.push(`${mutation.path}: no captured AFTER content blob (sha=${mutation.beforeHash.slice(0, 12)}…) — redo not available`);
+                continue;
+            }
+            if (hashContent(content) !== mutation.beforeHash) {
+                unsafe.push(`${mutation.path}: blob sha mismatch (store may have been tampered with) — refusing to write`);
+                continue;
+            }
+            steps.push({
+                path: mutation.path,
+                replayOperation: 'update',
+                preReplayHash: mutation.afterHash,
+                postReplayHash: mutation.beforeHash,
+                content,
+                blobSha: mutation.beforeHash,
+            });
+            continue;
+        }
+        if (mutation.operation === 'update' && !mutation.beforeHash && mutation.afterHash) {
+            // Original op was `delete`. Post-undo file matches afterHash
+            // (= original beforeHash, restored from git HEAD). Redo = delete
+            // the file again. No blob lookup needed.
+            if (!existsSync(abs)) {
+                // Already gone — nothing to redo for this entry.
+                continue;
+            }
+            const current = readFileSync(abs, 'utf8');
+            if (hashContent(current) !== mutation.afterHash) {
+                unsafe.push(`${mutation.path}: modified externally since /undo — refusing to delete operator work`);
+                continue;
+            }
+            steps.push({
+                path: mutation.path,
+                replayOperation: 'delete',
+                preReplayHash: mutation.afterHash,
+                postReplayHash: undefined,
+            });
+            continue;
+        }
+        // Anything else (move undo, malformed entry) — refuse rather than
+        // partial-replay. Matches the undo runner's posture.
+        unsafe.push(`${mutation.path}: redo of inverse op '${mutation.operation}' is not supported in this build`);
+    }
+    if (unsafe.length > 0) {
+        return {
+            aborted: true,
+            reason: 'one or more files are unsafe to redo',
+            unsafe,
+            steps: [],
+        };
+    }
+    return { aborted: false, steps };
+}
+function executeReplay(root, step) {
+    const abs = resolve(root, step.path);
+    if (step.replayOperation === 'delete') {
+        if (existsSync(abs))
+            unlinkSync(abs);
+        return;
+    }
+    if (step.content === undefined) {
+        throw new Error(`internal: replay content missing for ${step.path}`);
+    }
+    // Atomic tmp+rename — same pattern as undo's executeRevert.
+    const tmp = `${abs}.pugi-redo-${Date.now()}`;
+    writeFileSync(tmp, step.content, { encoding: 'utf8', mode: 0o600 });
+    renameSync(tmp, abs);
+}
+//# sourceMappingURL=redo.js.map

package/dist/runtime/commands/status.js

@@ -108,6 +108,8 @@ export async function runStatusCommand(ctx) {
         liveTokensUsed: ctx.liveTokensUsed ?? null,
         lastCommand: ctx.lastCommand ?? null,
         lastCommandAtEpochMs: ctx.lastCommandAtEpochMs ?? null,
+        liveApiUrl: ctx.liveApiUrl ?? null,
+        workspaceLabel: ctx.workspaceLabel ?? null,
         fs: ctx.fs ?? DEFAULT_FS,
         resolveCredential: ctx.resolveCredential ?? (() => defaultResolveCredential(ctx.env, ctx.home)),
         resolvePermissionMode: ctx.resolvePermissionMode ?? (() => permissionMode),
@@ -155,13 +157,19 @@ export async function runStatusCommand(ctx) {
  * narrow terminals stay legible without a layout library.
  */
 export function renderStatusTable(snapshot) {
-    const labelWidth = Math.max('Label'.length, ...snapshot.fields.map((f) => f.label.length));
+    // Row syntax: `${Label}: ${value}` with exactly ONE space after the
+    // colon, then the value verbatim. The colon doubles as a visual
+    // anchor and the REPL spec assertions match on the single-space
+    // form (`Backend: https://api.pugi.io`) — multi-space column
+    // padding broke `.includes('Backend: https://...')` substring
+    // checks. Operators who want a column layout can run the Ink
+    // renderer (`<StatusTable>`); the plain-text fallback stays
+    // narrow-terminal friendly without padding columns.
     const lines = [];
     lines.push('Pugi status');
     lines.push('═'.repeat(50));
     for (const field of snapshot.fields) {
-        const labelPart = field.label.padEnd(labelWidth, ' ');
-        lines.push(`${labelPart}  ${field.value}`);
+        lines.push(`${field.label}: ${field.value}`);
     }
     lines.push('');
     lines.push(`CLI ${snapshot.meta.cliVersion}  Node ${snapshot.meta.nodeVersion}  cwd ${snapshot.meta.cwd}`);

package/dist/runtime/commands/undo.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from
 import { resolve } from 'node:path';
 import { hashContent } from '../../core/file-cache.js';
 import { recordFileMutation, recordToolCall, recordToolResult, } from '../../core/session.js';
+import { writeBlob } from './redo-blob-store.js';
 /**
  * `pugi undo` — revert the file mutations from the most recent successful
  * `write` / `edit` / `multi_edit` tool result.
@@ -81,6 +82,37 @@ export async function runUndoCommand(_args, ctx) {
     const restored = [];
     for (const step of plan.steps) {
         try {
+            // Wave 6 (2026-05-27): snapshot the AFTER state into the redo
+            // blob store BEFORE we revert the file on disk. /redo reads this
+            // blob keyed by `step.beforeHash` (= original afterHash) to
+            // reapply the change. We only snapshot for operations that have
+            // on-disk AFTER content: `create` (file exists, about to be
+            // deleted) and `update` (file exists, about to be overwritten).
+            // For `delete` reverts (file was deleted by Pugi, the "after" is
+            // nothing) redo replays the delete itself — no content needed.
+            // Best-effort: a blob-store failure must not abort the undo, so
+            // the writeBlob call is wrapped и any error swallowed.
+            if (step.operation === 'create' || step.operation === 'update') {
+                try {
+                    const abs = resolve(ctx.workspaceRoot, step.path);
+                    if (existsSync(abs) && step.beforeHash) {
+                        const current = readFileSync(abs, 'utf8');
+                        // Defensive: only snapshot if the current sha matches the
+                        // pre-revert hash the planner verified. The planner already
+                        // gated this, but a TOCTOU between plan + execute would
+                        // produce a wrong blob — silently dropping it is safer than
+                        // shipping content under the wrong sha.
+                        if (hashContent(current) === step.beforeHash) {
+                            writeBlob(ctx.workspaceRoot, current);
+                        }
+                    }
+                }
+                catch {
+                    // Best-effort. Failure to snapshot means /redo will report
+                    // "no captured content" — operator can re-run the mutation
+                    // manually. Better than aborting the undo.
+                }
+            }
             executeRevert(ctx.workspaceRoot, step);
             restored.push({ path: step.path, operation: step.operation });
         }

package/dist/runtime/headless-repl.js

@@ -0,0 +1,195 @@
+/**
+ * Headless REPL — `pugi --headless` (BIG TRACK 10 Phase 1, 2026-05-27).
+ *
+ * Long-form rationale lives in the spec PR; the short version: every
+ * CLI publish gets manually smoke-tested today (CEO directive
+ * `feedback_live_console_test_every_publish`) and that toil must be
+ * automated. `pugi --headless` is the I/O surface that lets a scripted
+ * harness drive Pugi multi-turn — one stdin line in, one or more JSON
+ * envelopes out on stdout, exit when stdin closes. This is the
+ * machine-facing peer to the human-facing Ink REPL.
+ *
+ * Envelope shape (Phase 1):
+ *
+ *   { "kind": "user-turn"   | "persona-turn" | "tool-call" | "error"
+ *           | "session-start" | "session-end" | "system",
+ *     "body": "<string>",
+ *     "ts":   <epoch ms> }
+ *
+ * One JSON object per line. Stdout stays pure envelopes; stderr gets
+ * any human-readable trace. Discipline mirrors the existing
+ * `runHeadlessPrint` in `headless.ts`.
+ *
+ * Phase 1 engine wiring — the headless REPL emits the user-turn
+ * envelope verbatim, then asks the engine adapter for ONE turn, then
+ * emits the persona-turn / tool-call envelopes. Multi-turn state is
+ * accumulated in a single in-process session so consecutive lines see
+ * the same persona history. When a credential is absent (a common CI
+ * state) we fall through to a deterministic stub responder so the
+ * smoke harness can still exercise the I/O contract WITHOUT requiring
+ * an api.pugi.io reachability dependency.
+ */
+import { createInterface } from 'node:readline';
+import { resolve as resolvePath } from 'node:path';
+import { resolveActiveCredential } from '../core/credentials.js';
+/**
+ * Run the headless REPL loop. Returns the desired process exit code:
+ *
+ *   0  Stdin closed cleanly after at least one successful turn.
+ *   0  Stdin closed with no input (empty pipe — harmless, exit clean).
+ *   1  Fatal error from the turn handler.
+ *
+ * The caller (cli.ts) sets `process.exitCode`; we never call
+ * `process.exit` so an embedded driver can reuse the function.
+ */
+export async function runHeadlessRepl(opts) {
+    const cwd = resolvePath(opts.cwd);
+    const stdoutWrite = opts.stdoutWrite ?? ((chunk) => process.stdout.write(chunk));
+    const stderrWrite = opts.stderrWrite ?? ((chunk) => process.stderr.write(chunk));
+    const now = opts.now ?? Date.now;
+    const turnHandler = opts.turnHandler ?? buildDefaultTurnHandler();
+    const stdin = opts.stdin ?? process.stdin;
+    emit(stdoutWrite, {
+        kind: 'session-start',
+        body: JSON.stringify({ cwd, cliVersion: 'phase1' }),
+        ts: now(),
+    });
+    const rl = createInterface({
+        input: stdin,
+        crlfDelay: Infinity,
+        terminal: false,
+    });
+    let turnIndex = 0;
+    let fatal = false;
+    for await (const rawLine of rl) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line.length === 0)
+            continue;
+        emit(stdoutWrite, {
+            kind: 'user-turn',
+            body: line,
+            ts: now(),
+        });
+        try {
+            const out = await turnHandler({ line, turnIndex, cwd });
+            for (const env of out) {
+                emit(stdoutWrite, { kind: env.kind, body: env.body, ts: now() });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            emit(stdoutWrite, {
+                kind: 'error',
+                body: JSON.stringify({ message }),
+                ts: now(),
+            });
+            stderrWrite(`pugi --headless: turn handler threw: ${message}\n`);
+            fatal = true;
+            break;
+        }
+        turnIndex += 1;
+    }
+    emit(stdoutWrite, {
+        kind: 'session-end',
+        body: JSON.stringify({ turns: turnIndex }),
+        ts: now(),
+    });
+    return fatal ? 1 : 0;
+}
+/**
+ * Emit a single envelope to stdout. Always terminates with `\n` so a
+ * line-buffered reader (the smoke runner, jq, etc.) sees each
+ * envelope atomically.
+ */
+function emit(write, envelope) {
+    write(`${JSON.stringify(envelope)}\n`);
+}
+/**
+ * Build the default turn handler. When a Pugi credential is resolvable
+ * we'll plumb to the engine adapter in Phase 2; for Phase 1 the
+ * default responder is a deterministic stub. Smoke scenarios that
+ * exercise the engine path use a Phase-2-only flag (`PUGI_HEADLESS_LIVE=1`)
+ * to opt into the real engine; the default keeps CI offline-safe.
+ */
+function buildDefaultTurnHandler() {
+    const credential = resolveActiveCredential();
+    if (credential && process.env.PUGI_HEADLESS_LIVE === '1') {
+        // Phase 2: route through `NativePugiEngineAdapter` here. Left as a
+        // stub so the Phase 1 PR stays narrowly scoped to the I/O surface.
+        // The smoke corpus does NOT exercise this branch in Phase 1.
+        return stubResponder('live engine path not yet wired (Phase 2)');
+    }
+    return stubResponder('pugi headless stub: no credential or PUGI_HEADLESS_LIVE!=1; echoing input');
+}
+/**
+ * Tiny deterministic responder used by Phase 1 smoke tests. Echoes the
+ * input back as a `persona-turn` envelope with a stable prefix so
+ * scenarios can author assertions against it. The contract is:
+ *
+ *   - Input "ты кто?"                → persona-turn "Pugi: ты кто? (stub)"
+ *   - Input "create FILE with content X"
+ *                                    → tool-call Write file=FILE +
+ *                                      persona-turn "Pugi: wrote FILE"
+ *   - Any other input                → persona-turn "Pugi: ...(stub)"
+ *
+ * Real engine routing is Phase 2. The stub exists to validate the
+ * envelope contract end-to-end in CI without depending on api.pugi.io.
+ */
+function stubResponder(banner) {
+    return async (input) => {
+        const text = input.line.trim();
+        const envelopes = [];
+        const createMatch = /^create\s+(\S+)\s+with\s+content\s+['"]([^'"]+)['"]\s*$/i.exec(text);
+        if (createMatch) {
+            const file = createMatch[1] ?? 'unknown';
+            const body = createMatch[2] ?? '';
+            const { writeFileSync, mkdirSync } = await import('node:fs');
+            const { dirname } = await import('node:path');
+            const absolute = resolvePath(input.cwd, file);
+            try {
+                mkdirSync(dirname(absolute), { recursive: true });
+                writeFileSync(absolute, body, 'utf8');
+            }
+            catch (error) {
+                envelopes.push({
+                    kind: 'error',
+                    body: JSON.stringify({
+                        message: `write failed: ${error.message}`,
+                    }),
+                });
+                return envelopes;
+            }
+            envelopes.push({
+                kind: 'tool-call',
+                body: JSON.stringify({
+                    tool: 'Write',
+                    args: { file, content: body },
+                }),
+            });
+            envelopes.push({
+                kind: 'persona-turn',
+                body: `Pugi: wrote ${file}`,
+            });
+            return envelopes;
+        }
+        if (/^ты\s+кто/i.test(text) || /^who\s+are\s+you/i.test(text)) {
+            envelopes.push({
+                kind: 'persona-turn',
+                body: 'Pugi: я Pugi, твой co-pilot. (Пуджи, stub)',
+            });
+            return envelopes;
+        }
+        envelopes.push({
+            kind: 'persona-turn',
+            body: `Pugi: ${text} (stub)`,
+        });
+        // One-time banner on the first turn so operators see why the stub
+        // is firing. Suppressed on subsequent turns to keep the envelope
+        // stream noise-free.
+        if (input.turnIndex === 0) {
+            envelopes.push({ kind: 'system', body: banner });
+        }
+        return envelopes;
+    };
+}
+//# sourceMappingURL=headless-repl.js.map

package/dist/runtime/version.js

@@ -44,7 +44,7 @@ export function sanitizeSemver(raw) {
  * during import). When bumping the CLI version BOTH literals must be
  * updated; the release smoke-test (`pack:smoke`) verifies they agree.
  */
-export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.31');
+export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.35');
 /**
  * Outbound: the CLI's installed semver. Read at request time by
  * `version-interceptor.ts` and injected on every `fetch` call.