@yagni-app/code-staging 1.0.0-staging.1177.1 → 1.0.0-staging.1178.1

package/dist/cli.js

@@ -28,6 +28,7 @@ import { logout } from "./logout.js";
 import { tokenCommand } from "./token.js";
 import { buildLaunch } from "./launch.js";
 import { parseOutputFormat, parseJsonEvents, buildResultObject, readGuardianEvents, } from "./outputFormat.js";
+import { feedbackCommand } from "./feedback.js";
 import { runDoctor } from "./doctor.js";
 import { installProcessCrashHandlers } from "./crashReport.js";
 import { currentCliVersion, maybeNudgeAndRefresh, upgradeCommand } from "./upgrade.js";
@@ -335,6 +336,9 @@ export const HELP_TEXT = [
     "  yagni login              Authorize the active environment (device-code flow).",
     "  yagni logout             Revoke and clear the active environment's token.",
     "  yagni doctor             Check that everything is ready (green/red checklist).",
+    "  yagni feedback [sessionId]  File a bug report from the shell. Lists recent",
+    "                           sessions to pick, or pass a session ID directly.",
+    "                           Attaches transcript + error trail, then submits.",
     "  yagni go --headless      Run the /go pipeline without a session, for scripts",
     "                           and CI: --ticket-file <path> [--plan-file <path>]",
     "                           [--memo-file <path>] [--run-id <id>] [--json].",
@@ -486,6 +490,9 @@ export async function main(argv) {
     if (command === "go") {
         return goCommand(rest, {}, cliVersion());
     }
+    if (command === "feedback") {
+        return feedbackCommand(rest, {}, cliVersion());
+    }
     if (command === "token") {
         return tokenCommand();
     }

package/dist/crashReport.d.ts

@@ -41,6 +41,7 @@ export declare function crashReportsDisabled(env?: NodeJS.ProcessEnv): boolean;
 export declare function runningUnderTest(env?: NodeJS.ProcessEnv): boolean;
 /** Reporting is off when the user disabled it OR this is a test process. */
 export declare function crashReportsSuppressed(env?: NodeJS.ProcessEnv): boolean;
+export declare const SECRET_PATTERNS: Array<[RegExp, string]>;
 export interface SanitizeCrashOptions {
     /** Environment whose values get redacted (defaults to process.env). */
     env?: NodeJS.ProcessEnv;
@@ -57,6 +58,13 @@ export interface SanitizeCrashOptions {
  *      `node_modules/` on, so dependency frames stay diagnosable)
  * Over-redacts rather than under-redacts; pure; never throws.
  */
+/**
+ * Lightweight secret-only scrub — applies SECRET_PATTERNS and nothing else.
+ * Matches the extension's `scrubSecrets` exactly (no path collapse, no env
+ * redaction). Use this for feedback transcripts where file paths and code
+ * context must stay readable; the backend re-normalizes home paths on receipt.
+ */
+export declare function scrubSecrets(text: string): string;
 export declare function sanitizeCrashText(text: string, opts?: SanitizeCrashOptions): string;
 export interface SanitizedCrash {
     errorClass: string;

package/dist/crashReport.js

@@ -62,7 +62,7 @@ export function crashReportsSuppressed(env = process.env) {
 }
 // Mirrors scrubSecrets (backend yagniCode/scrubSecrets.ts and
 // pi-extension-yagni pipeline/scrubSecrets.ts) — keep in sync.
-const SECRET_PATTERNS = [
+export const SECRET_PATTERNS = [
     [/\b([a-z][a-z0-9+.\-]*:\/\/[^\s:@/]+):[^\s:@/]+@/gi, "$1:[REDACTED]@"],
     [/\b(sk-[A-Za-z0-9]{16,}|sk_(?:live|test)_[A-Za-z0-9]{16,}|rk_(?:live|test)_[A-Za-z0-9]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_\-]{20,})\b/g, "[REDACTED]"],
     [/\b([A-Za-z0-9_]*(?:secret|password|passwd|api[_-]?key|token|private[_-]?key|access[_-]?key)[A-Za-z0-9_]*)\b(\s*[:=]\s*)("[^"]+"|'[^']+'|`[^`]+`|[^\s"']+)/gi, "$1$2[REDACTED]"],
@@ -106,6 +106,18 @@ function collapsePathToken(token) {
  *      `node_modules/` on, so dependency frames stay diagnosable)
  * Over-redacts rather than under-redacts; pure; never throws.
  */
+/**
+ * Lightweight secret-only scrub — applies SECRET_PATTERNS and nothing else.
+ * Matches the extension's `scrubSecrets` exactly (no path collapse, no env
+ * redaction). Use this for feedback transcripts where file paths and code
+ * context must stay readable; the backend re-normalizes home paths on receipt.
+ */
+export function scrubSecrets(text) {
+    let out = text;
+    for (const [re, repl] of SECRET_PATTERNS)
+        out = out.replace(re, repl);
+    return out;
+}
 export function sanitizeCrashText(text, opts = {}) {
     let out = text;
     const env = opts.env ?? process.env;

package/dist/feedback.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `yagni feedback [sessionId]` — file a bug report from the shell (YAG-592).
+ *
+ * A shortcut to trigger what `/feedback` does inside a session, but from
+ * outside the TUI. Two modes:
+ *
+ *   Case A (no session arg): list the 10 most recent sessions for the current
+ *     cwd, let the user pick, prompt for a description, confirm, submit.
+ *   Case B (session ID provided): skip the list, go straight to description
+ *     prompt → confirm → submit.
+ *
+ * Self-contained: no cross-package imports. The scrub (`scrubSecrets`) and the
+ * error-trail reader (`readSessionTrail`) are local copies of the extension's
+ * logic — keep in sync with `pi-extension-yagni/src/pipeline/scrubSecrets.ts`
+ * and `pi-extension-yagni/src/errorSink.ts`. The backend re-scrubs server-side
+ * (`backend/src/yagniCode/feedback.ts`), so the client-side scrub is the first
+ * line of defense, not the only one.
+ */
+export interface FeedbackDeps {
+    loadCredentials?: () => Promise<{
+        token?: string;
+        baseUrl: string;
+        name: string;
+    }>;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    /** Override the agent dir (sessions live under `<agentDir>/sessions/...`). */
+    agentDirPath?: string;
+    /** Override the state dir (error sink lives under `<stateDir>/logs/...`). */
+    stateDir?: string;
+    writeOut?: (line: string) => void;
+    writeErr?: (line: string) => void;
+    /** Seam for readline — tests inject a fake that returns scripted answers. */
+    readline?: {
+        question: (q: string) => Promise<string>;
+        close: () => void;
+    };
+}
+export interface SessionInfo {
+    id: string;
+    filePath: string;
+    startTime: string;
+    durationMs: number | null;
+    firstMessage: string;
+}
+/**
+ * Encode a cwd into pi's session directory name format:
+ * `/Users/foo/bar` → `--Users-foo-bar--`
+ * Mirrors pi's `migrations.js`: `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`
+ */
+export declare function encodeCwd(cwd: string): string;
+/**
+ * List the most recent sessions for the current cwd.
+ * Scans `<agentDir>/sessions/<encoded-cwd>/*.jsonl`, sorted by start time desc.
+ */
+export declare function listRecentSessions(agentDirPath: string, cwd: string, limit?: number, termCols?: number): SessionInfo[];
+/**
+ * Find a session file by UUID across all project dirs.
+ */
+export declare function findSessionById(agentDirPath: string, sessionId: string): {
+    filePath: string;
+    startTime: string;
+} | null;
+/**
+ * Read the durable transcript, clamped by byte size. Returns empty on any
+ * failure or when too large. Mirrors the extension's `readTranscript`.
+ */
+export declare function readTranscript(sessionFile: string | undefined): string;
+/**
+ * Read the session-scoped error trail from today's error sink file.
+ * Filters by sessionId and excludes debug-level entries. Scrubs each line.
+ * Mirrors the extension's `readSessionTrail` — keep in sync.
+ */
+export declare function readSessionTrail(sessionId: string, stateDir: string, maxBytes?: number): string;
+export declare function feedbackCommand(args: string[], deps?: FeedbackDeps, cliVersion?: string): Promise<number>;
+//# sourceMappingURL=feedback.d.ts.map

package/dist/feedback.js

@@ -0,0 +1,500 @@
+/**
+ * `yagni feedback [sessionId]` — file a bug report from the shell (YAG-592).
+ *
+ * A shortcut to trigger what `/feedback` does inside a session, but from
+ * outside the TUI. Two modes:
+ *
+ *   Case A (no session arg): list the 10 most recent sessions for the current
+ *     cwd, let the user pick, prompt for a description, confirm, submit.
+ *   Case B (session ID provided): skip the list, go straight to description
+ *     prompt → confirm → submit.
+ *
+ * Self-contained: no cross-package imports. The scrub (`scrubSecrets`) and the
+ * error-trail reader (`readSessionTrail`) are local copies of the extension's
+ * logic — keep in sync with `pi-extension-yagni/src/pipeline/scrubSecrets.ts`
+ * and `pi-extension-yagni/src/errorSink.ts`. The backend re-scrubs server-side
+ * (`backend/src/yagniCode/feedback.ts`), so the client-side scrub is the first
+ * line of defense, not the only one.
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { isatty } from "node:tty";
+import { agentDir, credentialsDir } from "./credentials.js";
+import { scrubSecrets } from "./crashReport.js";
+import { credentialsFromProfile, readActiveProfile } from "./profiles.js";
+const MAX_DESCRIPTION = 512;
+const MAX_TRANSCRIPT_READ_BYTES = 512 * 1024;
+const MAX_TRAIL_BYTES = 64 * 1024;
+const FIRST_MESSAGE_PREVIEW_FALLBACK = 60;
+/** Max chars for the first-message preview, capped by terminal width. */
+function previewMaxWidth(termCols) {
+    const cols = termCols ?? process.stdout.columns;
+    if (!cols || cols < 40)
+        return FIRST_MESSAGE_PREVIEW_FALLBACK;
+    // Account for: "  " + " N. " (5) + time (18) + dur (6) = ~29 chars of prefix
+    const available = cols - 32;
+    return Math.max(available, 20);
+}
+const LIST_LIMIT = 10;
+// --- session discovery ---
+/**
+ * Encode a cwd into pi's session directory name format:
+ * `/Users/foo/bar` → `--Users-foo-bar--`
+ * Mirrors pi's `migrations.js`: `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`
+ */
+export function encodeCwd(cwd) {
+    return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+/**
+ * Parse the first few lines of a session JSONL to extract metadata.
+ * Returns null on any failure (corrupt/empty file).
+ */
+function parseSessionHeader(filePath) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === "session" && typeof obj.id === "string" && typeof obj.timestamp === "string") {
+                    return { id: obj.id, timestamp: obj.timestamp };
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract the first user message text from a session JSONL (skips
+ * `custom_message` entries — only real `type: "message"` with `role: "user"`).
+ */
+function extractFirstUserMessage(filePath, maxChars) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === "message" &&
+                    obj.message?.role === "user" &&
+                    Array.isArray(obj.message?.content)) {
+                    const textPart = obj.message.content.find((c) => c.type === "text");
+                    if (textPart?.text) {
+                        // Strip skill invocation XML tags (e.g. `<skill name="…" …>`)
+                        // — they're machinery, not the user's message.
+                        let text = textPart.text.trim()
+                            .replace(/<skill\s[^>]*>\s*/g, "")
+                            .replace(/<\/skill>/g, "")
+                            .replace(/\n+/g, " ")
+                            .trim();
+                        const cap = maxChars ?? FIRST_MESSAGE_PREVIEW_FALLBACK;
+                        if (text.length > 0) {
+                            return text.length > cap
+                                ? `${text.slice(0, cap)}…`
+                                : text;
+                        }
+                    }
+                }
+            }
+            catch {
+                // skip unparseable lines
+            }
+        }
+        return "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Get the timestamp of the last non-empty line in a session JSONL.
+ * Used to compute session duration.
+ */
+function extractLastTimestamp(filePath) {
+    try {
+        const data = readFileSync(filePath, "utf8");
+        const lines = data.split("\n").filter((l) => l.length > 0);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const obj = JSON.parse(lines[i]);
+                if (typeof obj.timestamp === "string")
+                    return obj.timestamp;
+            }
+            catch {
+                // skip
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List the most recent sessions for the current cwd.
+ * Scans `<agentDir>/sessions/<encoded-cwd>/*.jsonl`, sorted by start time desc.
+ */
+export function listRecentSessions(agentDirPath, cwd, limit = LIST_LIMIT, termCols) {
+    const sessionsDir = join(agentDirPath, "sessions", encodeCwd(cwd));
+    let files;
+    try {
+        files = readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+    }
+    catch {
+        return [];
+    }
+    const sessions = [];
+    for (const file of files) {
+        const filePath = join(sessionsDir, file);
+        const header = parseSessionHeader(filePath);
+        if (!header)
+            continue;
+        const firstMessage = extractFirstUserMessage(filePath, previewMaxWidth(termCols));
+        const lastTs = extractLastTimestamp(filePath);
+        let durationMs = null;
+        if (lastTs) {
+            const start = Date.parse(header.timestamp);
+            const end = Date.parse(lastTs);
+            if (!isNaN(start) && !isNaN(end))
+                durationMs = end - start;
+        }
+        sessions.push({
+            id: header.id,
+            filePath,
+            startTime: header.timestamp,
+            durationMs,
+            firstMessage,
+        });
+    }
+    sessions.sort((a, b) => b.startTime.localeCompare(a.startTime));
+    return sessions.slice(0, limit);
+}
+/**
+ * Find a session file by UUID across all project dirs.
+ */
+export function findSessionById(agentDirPath, sessionId) {
+    const sessionsRoot = join(agentDirPath, "sessions");
+    let projectDirs;
+    try {
+        projectDirs = readdirSync(sessionsRoot, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => join(sessionsRoot, d.name));
+    }
+    catch {
+        return null;
+    }
+    for (const dir of projectDirs) {
+        let files;
+        try {
+            files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            if (file.includes(sessionId)) {
+                const filePath = join(dir, file);
+                const header = parseSessionHeader(filePath);
+                if (header)
+                    return { filePath, startTime: header.timestamp };
+            }
+        }
+    }
+    return null;
+}
+// --- transcript + error trail ---
+/**
+ * Read the durable transcript, clamped by byte size. Returns empty on any
+ * failure or when too large. Mirrors the extension's `readTranscript`.
+ */
+export function readTranscript(sessionFile) {
+    if (!sessionFile)
+        return "";
+    try {
+        const data = readFileSync(sessionFile, "utf8");
+        if (Buffer.byteLength(data, "utf8") > MAX_TRANSCRIPT_READ_BYTES)
+            return "";
+        return data;
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Read the session-scoped error trail from today's error sink file.
+ * Filters by sessionId and excludes debug-level entries. Scrubs each line.
+ * Mirrors the extension's `readSessionTrail` — keep in sync.
+ */
+export function readSessionTrail(sessionId, stateDir, maxBytes = MAX_TRAIL_BYTES) {
+    try {
+        const dayStamp = new Date().toISOString().slice(0, 10);
+        const sinkPath = join(stateDir, "logs", `errors-${dayStamp}.jsonl`);
+        const data = readFileSync(sinkPath, "utf8");
+        const lines = data
+            .split("\n")
+            .filter((l) => l.length > 0)
+            .filter((l) => {
+            try {
+                const obj = JSON.parse(l);
+                return obj.sessionId === sessionId && obj.level !== "debug";
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((l) => scrubSecrets(l))
+            .join("\n");
+        return lines.length > maxBytes ? lines.slice(lines.length - maxBytes) : lines;
+    }
+    catch {
+        return "";
+    }
+}
+function buildFeedbackPayload(opts) {
+    const transcript = readTranscript(opts.sessionFile);
+    const trail = readSessionTrail(opts.sessionId, opts.stateDir);
+    return {
+        client: "cli",
+        clientVersion: opts.env.YAGNI_CODE_VERSION?.trim() || opts.clientVersion || "unknown",
+        platform: `${process.platform} ${process.arch}`,
+        description: scrubSecrets(opts.description).slice(0, MAX_DESCRIPTION),
+        sessionId: opts.sessionId,
+        ...(transcript ? { transcriptJsonl: scrubSecrets(transcript) } : {}),
+        ...(trail ? { errorTrailJsonl: trail } : {}),
+    };
+}
+async function submitFeedback(payload, baseUrl, token, fetchImpl) {
+    try {
+        const res = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/api/yagni-code/feedback`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (res.ok) {
+            const body = (await res.json().catch(() => ({})));
+            return { ok: true, id: body.id };
+        }
+        return { ok: false, error: `Server returned ${res.status}` };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Create a readline-like interface that survives piped stdin (where the
+ * real readline's `question` hangs after EOF). For TTY stdin it delegates to
+ * the real `readline/promises`; for piped stdin it reads all lines upfront
+ * and serves them one-by-one.
+ */
+function makeReadline() {
+    if (isatty(0)) {
+        const rl = createInterface({ input, output });
+        return {
+            question: (q) => rl.question(q),
+            close: () => rl.close(),
+        };
+    }
+    // Piped stdin: read all available data and serve lines FIFO.
+    const lines = [];
+    try {
+        const data = readFileSync(0, "utf8"); // fd 0 = stdin
+        for (const line of data.split("\n")) {
+            if (line.length > 0)
+                lines.push(line);
+        }
+    }
+    catch {
+        // stdin not readable as a file — fall back to empty
+    }
+    let idx = 0;
+    return {
+        question: async (q) => {
+            process.stdout.write(q);
+            const answer = lines[idx++] ?? "";
+            // Echo a newline so subsequent prompts start on a new line (in TTY
+            // mode, readline echoes the user's Enter; piped mode does not).
+            process.stdout.write("\n");
+            return answer;
+        },
+        close: () => { },
+    };
+}
+// --- display ---
+function formatDuration(ms) {
+    if (ms === null)
+        return "";
+    if (ms < 1000)
+        return "<1s";
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m`;
+}
+function formatStartTime(iso) {
+    try {
+        const d = new Date(iso);
+        return d.toLocaleString("en-US", {
+            month: "short",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+    }
+    catch {
+        return iso;
+    }
+}
+// Minimal ANSI escape sequences for the session list.
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+function renderSessionList(sessions) {
+    const sep = DIM + "  " + "─".repeat(70) + RESET;
+    const lines = [BOLD + "  Recent sessions" + RESET, sep];
+    const countWidth = String(sessions.length).length;
+    for (let i = 0; i < sessions.length; i++) {
+        const s = sessions[i];
+        const num = ` ${i + 1}.`.padEnd(countWidth + 2);
+        const idx = GREEN + num + RESET + " ";
+        const time = DIM + formatStartTime(s.startTime).padEnd(17) + RESET + " ";
+        const dur = DIM + formatDuration(s.durationMs).padEnd(5) + RESET + " ";
+        const msg = s.firstMessage || "(no text)";
+        lines.push(`  ${idx}${time}${dur}${msg}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+// --- orchestration ---
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export async function feedbackCommand(args, deps = {}, cliVersion) {
+    const writeOut = deps.writeOut ?? ((line) => void process.stdout.write(`${line}\n`));
+    const writeErr = deps.writeErr ?? ((line) => void process.stderr.write(`${line}\n`));
+    const cwd = deps.cwd ?? process.cwd();
+    const env = deps.env ?? process.env;
+    // Load credentials (same pattern as goCommand).
+    const profile = await (deps.loadCredentials ?? (async () => {
+        const active = await readActiveProfile(env);
+        const creds = credentialsFromProfile(active);
+        return {
+            name: active.name,
+            baseUrl: active.baseUrl,
+            ...(creds?.token ? { token: creds.token } : {}),
+        };
+    }))();
+    if (!profile.token) {
+        writeErr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`yagni login\` first.`);
+        return 1;
+    }
+    const agentDirPath = deps.agentDirPath ?? agentDir(profile.name);
+    const stateDir = deps.stateDir ?? credentialsDir();
+    // Parse args: is the first positional a session UUID?
+    const sessionIdArg = args.find((a) => !a.startsWith("-") && UUID_RE.test(a));
+    let sessionFile;
+    let sessionId;
+    // One readline interface for all prompts. For piped stdin, makeReadline
+    // reads all lines upfront to avoid the readline/promises hang on EOF.
+    const rl = deps.readline ?? makeReadline();
+    const closeRl = () => {
+        if (deps.readline)
+            deps.readline.close();
+        else
+            rl.close();
+    };
+    try {
+        if (sessionIdArg) {
+            // Case B: session ID provided directly.
+            const found = findSessionById(agentDirPath, sessionIdArg);
+            if (!found) {
+                writeErr(`Session ${sessionIdArg} not found.`);
+                return 1;
+            }
+            sessionFile = found.filePath;
+            sessionId = sessionIdArg;
+        }
+        else {
+            // Case A: list sessions for the current cwd.
+            const sessions = listRecentSessions(agentDirPath, cwd);
+            if (sessions.length === 0) {
+                writeOut("No recent sessions found for this directory.");
+                return 1;
+            }
+            writeOut(renderSessionList(sessions));
+            const answer = (await rl.question(CYAN + "Select a session (1-" + sessions.length + "): " + RESET)).trim();
+            const idx = parseInt(answer, 10) - 1;
+            if (isNaN(idx) || idx < 0 || idx >= sessions.length) {
+                writeOut("Feedback cancelled.");
+                return 0;
+            }
+            sessionFile = sessions[idx].filePath;
+            sessionId = sessions[idx].id;
+        }
+        // Prompt for description.
+        const descAnswer = await rl.question(DIM + "Describe the issue (one or two lines):" + RESET + "\n> ");
+        const description = descAnswer.trim();
+        if (!description) {
+            writeOut("Feedback cancelled.");
+            return 0;
+        }
+        // Confirm.
+        const transcriptBytes = sessionFile
+            ? Buffer.byteLength(readTranscript(sessionFile), "utf8")
+            : 0;
+        const confirmLines = [
+            DIM + "Sending:" + RESET,
+            `  - Your feedback description`,
+            `  - This session's transcript${transcriptBytes > 0 ? "" : " (could not be read)"}`,
+            `  - Recent error trail for this session`,
+            "",
+            CYAN + "Send this report? [Y/n]" + RESET,
+        ];
+        const confirmed = (await rl.question(confirmLines.join("\n") + "\n")).trim();
+        if (/^n/i.test(confirmed)) {
+            writeOut("Feedback cancelled.");
+            return 0;
+        }
+        // Build payload + submit.
+        const payload = buildFeedbackPayload({
+            sessionId,
+            sessionFile,
+            description,
+            stateDir,
+            env,
+            clientVersion: cliVersion ?? "unknown",
+        });
+        const fetchImpl = deps.fetchImpl ?? fetch;
+        const result = await submitFeedback(payload, profile.baseUrl, profile.token, fetchImpl);
+        if (result.ok) {
+            writeOut(GREEN + "Feedback submitted. Thank you!" + RESET);
+            return 0;
+        }
+        else {
+            writeErr(`Could not submit feedback. ${result.error ?? "Please try again."}`);
+            return 1;
+        }
+    }
+    catch {
+        // readline closed or EOF — treat as cancel.
+        writeOut("Feedback cancelled.");
+        return 0;
+    }
+    finally {
+        closeRl();
+    }
+}
+//# sourceMappingURL=feedback.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.0.0-staging.1177.1",
+  "version": "1.0.0-staging.1178.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -40,5 +40,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "92209df02c3660ed50b91a72f3197d47c2003e1d"
+  "yagniSourceSha": "d40167f97866479e71acceaf2132ed58f00cc0cc"
 }