@yagni-app/code 0.3.5 → 1.0.1

package/dist/extension/webFetch.js

@@ -0,0 +1,192 @@
+/**
+ * WebFetch core: fetch + convert + extract, adapted from Claude Code's
+ * WebFetchTool (src/tools/WebFetchTool/utils.ts). Pure and pi-free so it is
+ * fully unit-testable against fixtures, mirroring resilientFetch.ts.
+ *
+ * Three stages:
+ *   1. FETCH    an arbitrary URL with a PLAIN fetch impl (deliberately NOT the
+ *               authed fetch — see the token-leak note below).
+ *   2. CONVERT  HTML → markdown via turndown; non-HTML passes through raw.
+ *   3. EXTRACT  a `standard`-tier completion against the user's prompt.
+ *
+ * SECURITY (token leak): the extension's `makeAuthedFetch` transparently
+ * re-sends a second request WITH a fresh `Bearer $YAGNI_TOKEN` whenever the
+ * first returns 401 (tokenProvider.ts). Routing that wrapper at an arbitrary
+ * host would leak the token to any site that answers 401. The URL fetch must
+ * therefore use a plain global fetch, never opts.fetchImpl.
+ */
+/** Upper bound on the markdown handed to the extraction model (Claude's cap). */
+export const MAX_MARKDOWN_LENGTH = 100_000;
+/** Upper bound on the raw HTTP body we will accept (Claude's PSR cap). */
+export const MAX_HTTP_CONTENT_LENGTH = 10 * 1024 * 1024;
+/** Per-request wall clock for the URL fetch (Claude's 60s). */
+export const FETCH_TIMEOUT_MS = 60_000;
+/** Same-host redirect hop cap (Claude's 10, matching common client defaults). */
+export const MAX_REDIRECTS = 10;
+/** URLs longer than this are rejected as a data-exfil surface (Claude). */
+const MAX_URL_LENGTH = 2000;
+/**
+ * Reject URLs that could exfiltrate credentials or reach the user's own
+ * machine/network. Ported from Claude's validateURL: >2k chars, embedded
+ * userinfo, and single-label (non-public) hostnames are all refused.
+ */
+export function validateUrl(url) {
+    if (url.length > MAX_URL_LENGTH)
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.username || parsed.password)
+        return false;
+    const parts = parsed.hostname.split(".");
+    if (parts.length < 2)
+        return false;
+    return true;
+}
+/**
+ * Whether a redirect may be followed: same protocol/port, no userinfo, and the
+ * host differs only by an optional leading `www.`. Ported from Claude.
+ */
+export function isPermittedRedirect(originalUrl, redirectUrl) {
+    try {
+        const orig = new URL(originalUrl);
+        const redir = new URL(redirectUrl);
+        if (redir.protocol !== orig.protocol)
+            return false;
+        if (redir.port !== orig.port)
+            return false;
+        if (redir.username || redir.password)
+            return false;
+        const stripWww = (host) => host.replace(/^www\./, "");
+        return stripWww(orig.hostname) === stripWww(redir.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+/** Lazily import turndown once, on first HTML fetch. */
+let turndownService;
+async function getTurndown() {
+    if (!turndownService) {
+        const Turndown = (await import("turndown")).default;
+        turndownService = new Turndown();
+    }
+    return turndownService;
+}
+/**
+ * Fetch `url` (following only same-host redirects) and convert the body to
+ * markdown. Returns the converted content, or a {@link RedirectInfo} when the
+ * response routes to a different host (the caller re-invokes with the new URL).
+ */
+export async function fetchMarkdown(url, opts = {}) {
+    if (!validateUrl(url))
+        throw new Error(`Invalid URL: "${url}"`);
+    const response = await fetchWithPermittedRedirects(url, opts, 0);
+    if ("type" in response)
+        return response;
+    const raw = Buffer.from(response.data);
+    const contentType = response.headers?.["content-type"] ?? "";
+    const bytes = raw.length;
+    const text = raw.toString("utf-8");
+    let content;
+    if (contentType.includes("text/html")) {
+        content = (await getTurndown()).turndown(text);
+    }
+    else {
+        content = text;
+    }
+    if (content.length > MAX_MARKDOWN_LENGTH) {
+        content = `${content.slice(0, MAX_MARKDOWN_LENGTH)}\n\n[Content truncated due to length...]`;
+    }
+    return {
+        content,
+        bytes,
+        code: response.status,
+        codeText: response.statusText,
+        contentType,
+    };
+}
+/** Low-level fetch with manual, same-host-only redirect following. */
+async function fetchWithPermittedRedirects(url, opts, depth) {
+    if (depth > MAX_REDIRECTS) {
+        throw new Error(`Too many redirects (exceeded ${MAX_REDIRECTS})`);
+    }
+    const signal = opts.signal;
+    const response = await (opts.fetchImpl ?? fetch)(url, {
+        method: "GET",
+        redirect: "manual",
+        signal,
+        headers: {
+            Accept: "text/markdown, text/html, */*",
+            "User-Agent": "YAGNI-Code (web-fetch)",
+        },
+    });
+    if ([301, 302, 307, 308].includes(response.status)) {
+        const location = response.headers.get("location");
+        if (!location)
+            throw new Error("Redirect missing Location header");
+        const redirectUrl = new URL(location, url).toString();
+        if (!isPermittedRedirect(url, redirectUrl)) {
+            return { type: "redirect", originalUrl: url, redirectUrl, statusCode: response.status };
+        }
+        return fetchWithPermittedRedirects(redirectUrl, opts, depth + 1);
+    }
+    const contentLength = Number(response.headers.get("content-length") ?? "0");
+    if (Number.isFinite(contentLength) && contentLength > MAX_HTTP_CONTENT_LENGTH) {
+        throw new Error(`Response exceeds ${MAX_HTTP_CONTENT_LENGTH} bytes`);
+    }
+    const data = await response.arrayBuffer();
+    if (data.byteLength > MAX_HTTP_CONTENT_LENGTH) {
+        throw new Error(`Response exceeds ${MAX_HTTP_CONTENT_LENGTH} bytes`);
+    }
+    const headers = {};
+    response.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    return { data, headers, status: response.status, statusText: response.statusText };
+}
+/**
+ * Build the extraction prompt: the fetched content plus the user's prompt plus
+ * the "answer only from the content" guardrails, mirroring Claude's
+ * makeSecondaryModelPrompt.
+ */
+export function makeExtractionPrompt(markdownContent, prompt) {
+    const guidelines = "Provide a concise response based only on the content above. In your response:\n" +
+        " - Enforce a strict 125-character maximum for quotes from any source document.\n" +
+        " - Use quotation marks for exact language; any language outside the quotation should never be word-for-word the same.";
+    return `Web page content:\n---\n${markdownContent}\n---\n\n${prompt}\n\n${guidelines}`;
+}
+/**
+ * Run the extraction: one `standard`-tier completion against the metric proxy
+ * (the same /v1/chat/completions surface pi's `yagni` provider drives). The
+ * content was already fetched locally; only this summarization rides the proxy.
+ */
+export async function extract(markdownContent, prompt, opts) {
+    const res = await (opts.fetchImpl ?? fetch)(`${opts.baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${opts.getToken() ?? ""}`,
+            ...opts.attribution(),
+        },
+        body: JSON.stringify({
+            model: "standard",
+            messages: [{ role: "user", content: makeExtractionPrompt(markdownContent, prompt) }],
+        }),
+        signal: opts.signal,
+    });
+    if (!res.ok) {
+        throw new Error(`web_fetch extraction failed: HTTP ${res.status}`);
+    }
+    const data = (await res.json());
+    const text = data.choices?.[0]?.message?.content;
+    if (typeof text !== "string") {
+        throw new Error("web_fetch extraction returned no content");
+    }
+    return { text };
+}
+//# sourceMappingURL=webFetch.js.map

package/dist/extension/webFetchTool.d.ts

@@ -0,0 +1,34 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { makeExtractionPrompt, MAX_MARKDOWN_LENGTH } from "./webFetch.js";
+export interface MakeWebFetchToolOptions {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    /**
+     * The authed fetch (makeAuthedFetch) used for the EXTRACTION call only. It is
+     * deliberately never used for the arbitrary URL fetch — see the token-leak
+     * note in webFetch.ts.
+     */
+    fetchImpl?: typeof fetch;
+    /**
+     * The PLAIN fetch used for the arbitrary URL fetch (defaults to global fetch,
+     * never the authed wrapper). Injectable so tests can stub the network without
+     * risking a real outbound request.
+     */
+    webFetchImpl?: typeof fetch;
+}
+declare const parameters: Type.TObject<{
+    url: Type.TString;
+    prompt: Type.TString;
+}>;
+/**
+ * Build the `web_fetch` tool definition — YAG-578.
+ *
+ * Fetches a URL, converts HTML to markdown, then extracts the requested
+ * information with a `standard`-tier completion. Read-only, client-side; it is
+ * the tidy replacement for a `bash` + `curl` + `python` fetch-and-strip dance.
+ */
+export declare function makeWebFetchTool(opts: MakeWebFetchToolOptions): ToolDefinition<typeof parameters, undefined>;
+/** Re-exported for tests that assemble the extraction prompt. */
+export { MAX_MARKDOWN_LENGTH, makeExtractionPrompt };
+//# sourceMappingURL=webFetchTool.d.ts.map

package/dist/extension/webFetchTool.js

@@ -0,0 +1,106 @@
+import { Container, Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { attributionHeaders } from "./config.js";
+import { markdownOrPlain } from "./subagentRender.js";
+import { extract, fetchMarkdown, makeExtractionPrompt, MAX_MARKDOWN_LENGTH, } from "./webFetch.js";
+const parameters = Type.Object({
+    url: Type.String({ description: "The URL to fetch content from" }),
+    prompt: Type.String({ description: "The prompt to run on the fetched content" }),
+});
+/** Collapsed preview length, in lines. */
+const PREVIEW_LINES = 8;
+function clipLine(text, max) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= max)
+        return collapsed;
+    return `${collapsed.slice(0, max - 1)}…`;
+}
+function hostOf(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * Build the `web_fetch` tool definition — YAG-578.
+ *
+ * Fetches a URL, converts HTML to markdown, then extracts the requested
+ * information with a `standard`-tier completion. Read-only, client-side; it is
+ * the tidy replacement for a `bash` + `curl` + `python` fetch-and-strip dance.
+ */
+export function makeWebFetchTool(opts) {
+    return {
+        name: "web_fetch",
+        label: "Web fetch",
+        description: "Fetch a URL, convert HTML to markdown, and extract the requested information " +
+            "using a small model. Read-only. Use this to read an arbitrary web page or docs " +
+            "URL (an API reference, a changelog, a docs page) instead of reaching for bash + curl. " +
+            "It will fail for authenticated or private URLs (Google Docs, Jira, GitHub, etc.) — " +
+            "use a specialized connector or MCP tool for those.",
+        promptSnippet: "web_fetch: fetch a URL, convert to markdown, and summarize against a prompt (read-only).",
+        promptGuidelines: [
+            "Use web_fetch to read a URL's content instead of bash + curl when you need a page or a summary of it.",
+        ],
+        parameters,
+        // Self-framed: the condensed transcript look has no tinted tool boxes.
+        renderShell: "self",
+        renderCall(args, theme) {
+            const t = theme;
+            const url = clipLine(args?.url ?? "…", 80);
+            const prompt = args?.prompt ? clipLine(args.prompt, 60) : "";
+            let text = `${t.fg("toolTitle", t.bold("web_fetch"))} ${t.fg("accent", url)}`;
+            if (prompt)
+                text += ` — ${t.fg("dim", prompt)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            const t = theme;
+            const content = result.content.find((c) => c.type === "text");
+            const text = content && "text" in content ? content.text : "";
+            if (isPartial)
+                return new Text(t.fg("muted", text || "Fetching…"), 0, 0);
+            if (expanded) {
+                const container = new Container();
+                container.addChild(markdownOrPlain(text || "(no content)", t));
+                return container;
+            }
+            const lines = text.trim().split("\n");
+            const out = lines.slice(0, PREVIEW_LINES).map((l) => t.fg("toolOutput", l));
+            if (lines.length > PREVIEW_LINES)
+                out.push(t.fg("muted", "  (ctrl+o to expand)"));
+            return new Text(out.join("\n"), 0, 0);
+        },
+        async execute(_toolCallId, params, signal, onUpdate) {
+            onUpdate?.({ content: [{ type: "text", text: "Fetching…" }], details: undefined });
+            const fetched = await fetchMarkdown(params.url, { fetchImpl: opts.webFetchImpl, signal });
+            // A cross-host redirect is not auto-followed; ask the model to re-call.
+            if (fetched.type === "redirect") {
+                const r = fetched;
+                const statusText = r.statusCode === 301 ? "Moved Permanently"
+                    : r.statusCode === 308 ? "Permanent Redirect"
+                        : r.statusCode === 307 ? "Temporary Redirect"
+                            : "Found";
+                const message = `REDIRECT DETECTED: The URL redirects to a different host.\n\n` +
+                    `Original URL: ${r.originalUrl}\nRedirect URL: ${r.redirectUrl}\n` +
+                    `Status: ${r.statusCode} ${statusText}\n\n` +
+                    `To complete your request, call web_fetch again with these parameters:\n` +
+                    `- url: "${r.redirectUrl}"\n- prompt: "${params.prompt}"`;
+                return { content: [{ type: "text", text: message }], details: undefined };
+            }
+            const content = fetched.content;
+            const { text } = await extract(content, params.prompt, {
+                baseUrl: opts.baseUrl,
+                getToken: opts.getToken,
+                fetchImpl: opts.fetchImpl,
+                attribution: () => attributionHeaders(),
+                signal,
+            });
+            return { content: [{ type: "text", text }], details: undefined };
+        },
+    };
+}
+/** Re-exported for tests that assemble the extraction prompt. */
+export { MAX_MARKDOWN_LENGTH, makeExtractionPrompt };
+//# sourceMappingURL=webFetchTool.js.map

package/dist/extension/workingLine.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The Claude Code-style streaming status line: `Shaping… (12m 54s · ↓ 47.5k
+ * tokens)` in place of pi's static "Working...".
+ *
+ * One manager owns `ctx.ui.setWorkingMessage` for the whole session so the
+ * verb, the elapsed clock, and the token counter never fight the subagent /
+ * advisor progress text: those tools publish their activity line through
+ * {@link WorkingLineHandle.setActivity} (instead of calling setWorkingMessage
+ * directly), and the manager splices it in as the head of the same composed
+ * message. Elapsed time spans the whole agent loop (agent_start → agent_end);
+ * the token counter accumulates assistant output tokens across the loop's
+ * messages (message_end), which is when pi learns usage — subagent tokens live
+ * in the subagent's own activity text, not this counter.
+ *
+ * TUI-only by the agent_start guard; a headless /go child or desktop surface
+ * never gets a working line. Everything is fail-soft: a status line must never
+ * break a turn.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/** What subagents/advisor publish instead of calling setWorkingMessage. */
+export interface WorkingLineHandle {
+    setActivity(text?: string): void;
+}
+/** A no-op handle for callers wired without a manager (tests, children). */
+export declare const NULL_WORKING_LINE: WorkingLineHandle;
+/**
+ * The verb pool. Neutral gerunds — one is picked per agent loop, so long
+ * sessions read as a person at work rather than a stuck spinner.
+ */
+export declare const WORKING_VERBS: readonly string[];
+/** Pulse frames for the streaming indicator (pi renders them verbatim). */
+export declare const WORKING_INDICATOR_FRAMES: string[];
+export interface ComposeWorkingOpts {
+    /** Override head from a running subagent/advisor (verb used when absent). */
+    activity?: string | undefined;
+    verb: string;
+    elapsedMs: number;
+    outputTokens: number;
+}
+/** `Shaping… (12m 54s · ↓ 47.5k tokens)` — pure, exported for tests. */
+export declare function composeWorkingMessage(opts: ComposeWorkingOpts): string;
+export interface RegisterWorkingLineDeps {
+    now?: () => number;
+    pickVerb?: (verbs: readonly string[]) => string;
+    /** Refresh cadence for the elapsed clock. */
+    tickMs?: number;
+}
+export declare function registerWorkingLine(pi: ExtensionAPI, deps?: RegisterWorkingLineDeps): WorkingLineHandle;
+//# sourceMappingURL=workingLine.d.ts.map

package/dist/extension/workingLine.js

@@ -0,0 +1,116 @@
+/**
+ * The Claude Code-style streaming status line: `Shaping… (12m 54s · ↓ 47.5k
+ * tokens)` in place of pi's static "Working...".
+ *
+ * One manager owns `ctx.ui.setWorkingMessage` for the whole session so the
+ * verb, the elapsed clock, and the token counter never fight the subagent /
+ * advisor progress text: those tools publish their activity line through
+ * {@link WorkingLineHandle.setActivity} (instead of calling setWorkingMessage
+ * directly), and the manager splices it in as the head of the same composed
+ * message. Elapsed time spans the whole agent loop (agent_start → agent_end);
+ * the token counter accumulates assistant output tokens across the loop's
+ * messages (message_end), which is when pi learns usage — subagent tokens live
+ * in the subagent's own activity text, not this counter.
+ *
+ * TUI-only by the agent_start guard; a headless /go child or desktop surface
+ * never gets a working line. Everything is fail-soft: a status line must never
+ * break a turn.
+ */
+import { usageFromMessage } from "./costHud.js";
+import { formatDuration, formatTokens } from "./subagentRender.js";
+/** A no-op handle for callers wired without a manager (tests, children). */
+export const NULL_WORKING_LINE = { setActivity: () => { } };
+/**
+ * The verb pool. Neutral gerunds — one is picked per agent loop, so long
+ * sessions read as a person at work rather than a stuck spinner.
+ */
+export const WORKING_VERBS = [
+    "Working",
+    "Thinking",
+    "Exploring",
+    "Tracing",
+    "Shaping",
+    "Wiring",
+    "Weighing",
+    "Sketching",
+    "Assembling",
+    "Distilling",
+    "Untangling",
+    "Polishing",
+];
+/** Pulse frames for the streaming indicator (pi renders them verbatim). */
+export const WORKING_INDICATOR_FRAMES = ["·", "✢", "✳", "✶", "✳", "✢"];
+/** `Shaping… (12m 54s · ↓ 47.5k tokens)` — pure, exported for tests. */
+export function composeWorkingMessage(opts) {
+    const head = opts.activity ?? `${opts.verb}…`;
+    const stats = [
+        formatDuration(opts.elapsedMs),
+        opts.outputTokens > 0 ? `↓ ${formatTokens(opts.outputTokens)} tokens` : undefined,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    return `${head} (${stats})`;
+}
+export function registerWorkingLine(pi, deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const pickVerb = deps.pickVerb ?? ((verbs) => verbs[Math.floor(Math.random() * verbs.length)]);
+    const tickMs = deps.tickMs ?? 1_000;
+    let ui;
+    let timer;
+    let startedAt;
+    let outputTokens = 0;
+    let verb = WORKING_VERBS[0];
+    let activity;
+    const refresh = () => {
+        if (!ui || startedAt === undefined)
+            return;
+        try {
+            ui.setWorkingMessage?.(composeWorkingMessage({ activity, verb, elapsedMs: now() - startedAt, outputTokens }));
+        }
+        catch {
+            // The status line must never break a turn.
+        }
+    };
+    const stop = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+        startedAt = undefined;
+        activity = undefined;
+        try {
+            ui?.setWorkingMessage?.();
+        }
+        catch {
+            // Restoring the default label is best-effort.
+        }
+    };
+    pi.on("agent_start", (_event, ctx) => {
+        if (ctx.mode !== "tui" || !ctx.hasUI)
+            return;
+        ui = ctx.ui;
+        startedAt = now();
+        outputTokens = 0;
+        activity = undefined;
+        verb = pickVerb(WORKING_VERBS);
+        refresh();
+        if (timer)
+            clearInterval(timer);
+        timer = setInterval(refresh, tickMs);
+        timer.unref?.();
+    });
+    pi.on("agent_end", () => stop());
+    pi.on("message_end", (event) => {
+        const message = event.message;
+        if (message?.role !== "assistant")
+            return;
+        outputTokens += usageFromMessage(message).output;
+        refresh();
+    });
+    return {
+        setActivity(text) {
+            activity = text;
+            refresh();
+        },
+    };
+}
+//# sourceMappingURL=workingLine.js.map

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