@repo-os/repoos 0.5.45

package/dist/core/providers/openrouter.js

@@ -0,0 +1,82 @@
+import { oneLineReason, parseJsonResponse } from "./types.js";
+const MODELS_URL = "https://openrouter.ai/api/v1/models";
+const FETCH_TIMEOUT_MS = 8000;
+const MAX_MODELS = 12;
+const MIN_CONTEXT_TOKENS = 32_000;
+/**
+ * Hygiene mirror of the server validator's runId model-segment charset
+ * (`RUN_ID_PATTERN` in src/server/routes/playground.ts): a catalog id using
+ * characters outside this set would be rejected at run time, so curate it
+ * out here rather than shipping a sidebar entry that 400s on click.
+ */
+const MODEL_ID_CHARSET = /^[\w.:/~-]+$/;
+function isTextModel(m) {
+    const arch = m.architecture;
+    if (!arch)
+        return true;
+    const input = arch.input_modalities ?? [];
+    const output = arch.output_modalities ?? [];
+    return input.includes("text") && output.includes("text");
+}
+function namespaceOf(id) {
+    return id.split("/")[0] ?? id;
+}
+/** OpenRouter prices are USD-per-token strings; $/1M tokens = price * 1,000,000. */
+function dollarsPerMillion(perTokenUsd) {
+    const n = Number(perTokenUsd);
+    return Number.isFinite(n) && n > 0 ? n * 1_000_000 : null;
+}
+/** A malformed/non-positive `context_length` isn't a usable context window. */
+function positiveContextWindow(contextLength) {
+    return typeof contextLength === "number" && Number.isFinite(contextLength) && contextLength > 0
+        ? contextLength
+        : null;
+}
+/** Curate + parse OpenRouter's models response into playground models. Exported for tests. */
+export function curateOpenRouterModels(models) {
+    const candidates = models.filter((m) => {
+        if (!m.id || m.id.endsWith(":free") || !MODEL_ID_CHARSET.test(m.id))
+            return false;
+        if (!isTextModel(m))
+            return false;
+        const promptPrice = Number(m.pricing?.prompt ?? "0");
+        if (!(promptPrice > 0))
+            return false;
+        if ((m.context_length ?? 0) < MIN_CONTEXT_TOKENS)
+            return false;
+        return true;
+    });
+    const bestPerNamespace = new Map();
+    for (const m of candidates) {
+        const ns = namespaceOf(m.id);
+        const current = bestPerNamespace.get(ns);
+        if (!current || (m.context_length ?? 0) > (current.context_length ?? 0)) {
+            bestPerNamespace.set(ns, m);
+        }
+    }
+    return [...bestPerNamespace.values()]
+        .sort((a, b) => (b.context_length ?? 0) - (a.context_length ?? 0))
+        .slice(0, MAX_MODELS)
+        .map((m) => ({
+        id: m.id,
+        runId: `openrouter/${m.id}`,
+        name: m.name ?? m.id,
+        reason: oneLineReason(m.description, "Available through OpenRouter."),
+        inputPricePerM: dollarsPerMillion(m.pricing?.prompt),
+        outputPricePerM: dollarsPerMillion(m.pricing?.completion),
+        contextWindow: positiveContextWindow(m.context_length),
+    }));
+}
+export const openrouterProvider = {
+    id: "openrouter",
+    label: "OpenRouter",
+    async fetchModels() {
+        const res = await fetch(MODELS_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+        if (!res.ok)
+            throw new Error(`OpenRouter API returned ${res.status}`);
+        const body = await parseJsonResponse(res, "OpenRouter");
+        if (!Array.isArray(body.data))
+            throw new Error("OpenRouter API returned an unexpected shape");
+        return curateOpenRouterModels(body.data);
+    },
+};

package/dist/core/providers/spend.d.ts

@@ -0,0 +1,86 @@
+export type ModelProviderId = "openrouter" | "opencode-go" | "opencode-zen" | "deepinfra";
+/**
+ * One row of the Model providers tab. `kind: "live"` rows have a real spend
+ * API behind a user-pasted key (`envVar` names the `.env` variable and
+ * `configKey` the loadConfig section field the key is read back through);
+ * `kind: "link"` rows are dashboard link-outs with no key collection at all.
+ */
+export interface ModelProviderRow {
+    id: ModelProviderId;
+    label: string;
+    kind: "live" | "link";
+    dashboardUrl: string;
+    /** One line under the label explaining what the row shows and why. */
+    note: string;
+    envVar: string | null;
+    configKey: "openrouterApiKey" | "opencodeGoApiKey" | null;
+}
+export declare const MODEL_PROVIDERS: ModelProviderRow[];
+export declare function modelProviderById(id: string): ModelProviderRow | undefined;
+export interface OpenRouterCredits {
+    totalCredits: number | null;
+    totalUsage: number | null;
+    remaining: number | null;
+}
+export interface OpenRouterKeyInfo {
+    label: string | null;
+    usageDaily: number | null;
+    usageWeekly: number | null;
+    usageMonthly: number | null;
+    /** null = this key has no spend limit set. */
+    limit: number | null;
+    limitRemaining: number | null;
+    rateLimit: {
+        requests: number | null;
+        interval: string | null;
+    } | null;
+}
+export declare function parseOpenRouterCredits(body: unknown): OpenRouterCredits;
+export declare function parseOpenRouterKey(body: unknown): OpenRouterKeyInfo;
+export interface OpenRouterSpend {
+    credits: OpenRouterCredits | null;
+    creditsError: string | null;
+    key: OpenRouterKeyInfo | null;
+    keyError: string | null;
+}
+/**
+ * Fetch both OpenRouter endpoints in parallel. Per-endpoint failures are
+ * isolated: a key that can read `/key` but is refused by `/credits` (the
+ * credits endpoint requires an OpenRouter management key) still renders its
+ * key-side data with a clear note about the failed half, instead of losing
+ * everything to one upstream restriction.
+ */
+export declare function fetchOpenRouterSpend(apiKey: string): Promise<OpenRouterSpend>;
+export interface OpenCodeGoWindow {
+    /** Stable window id, e.g. "five_hour" | "weekly" | "monthly". */
+    id: string;
+    label: string;
+    /** 0–100, percent of this rolling window consumed. */
+    usedPct: number | null;
+    /** Dollar spend inside the window, when the API reports one. */
+    usedUsd: number | null;
+    /** Window's dollar limit, when the API reports one. */
+    limitUsd: number | null;
+    /** ISO timestamp for when the window resets, when reported. */
+    resetsAt: string | null;
+}
+export interface OpenCodeGoUsage {
+    windows: OpenCodeGoWindow[];
+    /** True when the response parsed but no window shape was recognized. */
+    unrecognized: boolean;
+}
+/**
+ * Extract rolling usage windows from the Go usage response. The endpoint has
+ * no published response schema, so this accepts the plausible shapes —
+ * `{ windows: [...] }`, `{ data: { windows: [...] } }`, or a keyed object of
+ * window entries (`five_hour` / `weekly` / `monthly`, optionally nested under
+ * `usage`) — and reports `unrecognized` instead of guessing when none match.
+ */
+export declare function parseOpenCodeGoUsage(body: unknown): OpenCodeGoUsage;
+/**
+ * Fetch opencode Go's rolling usage windows. Throws with a clean message on
+ * any failure — the route maps that to a 502 and the row shows a retryable
+ * error. Unlike OpenRouter there is exactly one endpoint, so there is no
+ * per-part error isolation to preserve.
+ */
+export declare function fetchOpenCodeGoUsage(apiKey: string): Promise<OpenCodeGoUsage>;

package/dist/core/providers/spend.js

@@ -0,0 +1,286 @@
+/**
+ * Live spend/usage data for the Agents page's "Model providers" tab (0327).
+ *
+ * Scoped to the four v1 providers: OpenRouter and opencode Go expose real
+ * spend APIs and render live (each needs an API key the user pastes once —
+ * stored via `setDotEnvSecret`, never logged, never echoed back); opencode
+ * Zen and DeepInfra have no public balance/usage API and render as dashboard
+ * link-outs. All upstream calls are plain `fetch` with a hard timeout — zero
+ * runtime dependencies, same rule as the playground adapters next door.
+ *
+ * The parsers (`parseOpenRouterCredits`, `parseOpenRouterKey`,
+ * `parseOpenCodeGoUsage`) are separated from the fetchers so tests can pin
+ * the response shapes without stubbing global fetch, and so an upstream
+ * response shape change fails as a typed null instead of a crash.
+ */
+import { parseJsonResponse } from "./types.js";
+const OPENROUTER_BASE = "https://openrouter.ai/api/v1";
+const OPENCODE_GO_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
+const FETCH_TIMEOUT_MS = 8000;
+export const MODEL_PROVIDERS = [
+    {
+        id: "openrouter",
+        label: "OpenRouter",
+        kind: "live",
+        dashboardUrl: "https://openrouter.ai/credits",
+        note: "Credit balance, daily/weekly/monthly spend and rate limits, live from the OpenRouter API.",
+        envVar: "REPOOS_OPENROUTER_API_KEY",
+        configKey: "openrouterApiKey",
+    },
+    {
+        id: "opencode-go",
+        label: "opencode Go",
+        kind: "live",
+        dashboardUrl: "https://opencode.ai/auth",
+        note: "Rolling usage windows (5-hour / weekly / monthly), live from the Go usage API. No dollar balance exists.",
+        envVar: "REPOOS_OPENCODE_GO_API_KEY",
+        configKey: "opencodeGoApiKey",
+    },
+    {
+        id: "opencode-zen",
+        label: "opencode Zen",
+        kind: "link",
+        dashboardUrl: "https://opencode.ai/auth",
+        note: "No public balance API yet — balance and usage live in the Zen console.",
+        envVar: null,
+        configKey: null,
+    },
+    {
+        id: "deepinfra",
+        label: "DeepInfra",
+        kind: "link",
+        dashboardUrl: "https://deepinfra.com/dash/billing",
+        note: "No public billing/usage API — credit balance lives in the DeepInfra dashboard.",
+        envVar: null,
+        configKey: null,
+    },
+];
+export function modelProviderById(id) {
+    return MODEL_PROVIDERS.find((p) => p.id === id);
+}
+/** Upstream error text, extracted from the common `{ error: { message } }` shapes. */
+function upstreamError(body, fallback) {
+    if (typeof body === "object" && body !== null) {
+        const err = body.error;
+        if (typeof err === "string" && err.trim())
+            return err.trim();
+        if (typeof err === "object" && err !== null) {
+            const msg = err.message;
+            if (typeof msg === "string" && msg.trim())
+                return msg.trim();
+        }
+    }
+    return fallback;
+}
+/** A number field that is actually a finite number (null/undefined/"12" all fail). */
+function num(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+export function parseOpenRouterCredits(body) {
+    const data = body?.data ?? {};
+    const totalCredits = num(data.total_credits);
+    const totalUsage = num(data.total_usage);
+    return {
+        totalCredits,
+        totalUsage,
+        remaining: totalCredits != null && totalUsage != null ? totalCredits - totalUsage : null,
+    };
+}
+export function parseOpenRouterKey(body) {
+    const data = body?.data ?? {};
+    const rateLimit = data.rate_limit;
+    return {
+        label: typeof data.label === "string" && data.label ? data.label : null,
+        usageDaily: num(data.usage_daily),
+        usageWeekly: num(data.usage_weekly),
+        usageMonthly: num(data.usage_monthly),
+        limit: num(data.limit),
+        limitRemaining: num(data.limit_remaining),
+        rateLimit: rateLimit && typeof rateLimit === "object"
+            ? {
+                requests: num(rateLimit.requests),
+                interval: typeof rateLimit.interval === "string" ? rateLimit.interval : null,
+            }
+            : null,
+    };
+}
+async function getOpenRouterJson(path, apiKey) {
+    const res = await fetch(`${OPENROUTER_BASE}${path}`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+    const body = await parseJsonResponse(res, "OpenRouter");
+    return { body, status: res.status };
+}
+/**
+ * Fetch both OpenRouter endpoints in parallel. Per-endpoint failures are
+ * isolated: a key that can read `/key` but is refused by `/credits` (the
+ * credits endpoint requires an OpenRouter management key) still renders its
+ * key-side data with a clear note about the failed half, instead of losing
+ * everything to one upstream restriction.
+ */
+export async function fetchOpenRouterSpend(apiKey) {
+    const [credits, key] = await Promise.allSettled([
+        getOpenRouterJson("/credits", apiKey),
+        getOpenRouterJson("/key", apiKey),
+    ]);
+    const settle = (part) => {
+        if (part.status === "fulfilled") {
+            const { body, status } = part.value;
+            if (status >= 400) {
+                return { data: null, error: upstreamError(body, `OpenRouter API returned ${status}`) };
+            }
+            return { data: body, error: null };
+        }
+        return {
+            data: null,
+            error: part.reason instanceof Error ? part.reason.message : "OpenRouter request failed",
+        };
+    };
+    const creditsPart = settle(credits);
+    const keyPart = settle(key);
+    return {
+        credits: creditsPart.data != null ? parseOpenRouterCredits(creditsPart.data) : null,
+        creditsError: creditsPart.error,
+        key: keyPart.data != null ? parseOpenRouterKey(keyPart.data) : null,
+        keyError: keyPart.error,
+    };
+}
+const GO_WINDOW_LABELS = {
+    five_hour: "5-hour window",
+    "5h": "5-hour window",
+    fivehour: "5-hour window",
+    daily: "Daily window",
+    weekly: "Weekly window",
+    monthly: "Monthly window",
+};
+function windowLabel(id) {
+    const known = GO_WINDOW_LABELS[id.toLowerCase().replace(/[-_\s]/g, "")] ?? null;
+    if (known)
+        return known;
+    const text = id.replace(/[_-]+/g, " ").trim();
+    return text ? text.charAt(0).toUpperCase() + text.slice(1) : "Usage window";
+}
+function clampPct(v) {
+    return Math.max(0, Math.min(100, v));
+}
+/** Percent out of a window object, tolerating 0–1 ratios and 0–100 percents. */
+function windowPct(win) {
+    for (const k of ["utilization", "used_percent", "usedPercent", "percent_used", "percentUsed"]) {
+        const v = num(win[k]);
+        if (v != null)
+            return clampPct(v <= 1 ? v * 100 : v);
+    }
+    for (const k of ["percent", "percentage", "pct", "usedPct"]) {
+        const v = num(win[k]);
+        if (v != null)
+            return clampPct(v);
+    }
+    const used = num(win.used) ?? num(win.usage) ?? num(win.spent) ?? num(win.cost);
+    const limit = num(win.limit) ?? num(win.cap) ?? num(win.allowance) ?? num(win.max);
+    if (used != null && limit != null && limit > 0)
+        return clampPct((used / limit) * 100);
+    return null;
+}
+function windowResetsAt(win) {
+    for (const k of ["resets_at", "reset_at", "resetsAt", "resetAt"]) {
+        const v = win[k];
+        if (typeof v === "string" && v && !Number.isNaN(Date.parse(v)))
+            return new Date(v).toISOString();
+    }
+    const unix = num(win.resets_at_unix) ?? num(win.reset_at_unix) ?? num(win.resetsAtUnix);
+    if (unix != null && unix > 0) {
+        return new Date(unix < 1e12 ? unix * 1000 : unix).toISOString();
+    }
+    return null;
+}
+/** One recognized window entry from an id/name-ish key and a window object. */
+function windowFromEntry(id, win) {
+    const used = num(win.used) ?? num(win.usage) ?? num(win.spent) ?? num(win.cost);
+    const limit = num(win.limit) ?? num(win.cap) ?? num(win.allowance) ?? num(win.max);
+    return {
+        id,
+        label: typeof win.label === "string" && win.label ? win.label : windowLabel(id),
+        usedPct: windowPct(win),
+        usedUsd: used != null && used <= 10_000 ? used : null,
+        limitUsd: limit != null && limit <= 10_000 ? limit : null,
+        resetsAt: windowResetsAt(win),
+    };
+}
+const WINDOW_ID_KEYS = ["id", "type", "window", "name", "key", "period", "granularity"];
+/**
+ * Extract rolling usage windows from the Go usage response. The endpoint has
+ * no published response schema, so this accepts the plausible shapes —
+ * `{ windows: [...] }`, `{ data: { windows: [...] } }`, or a keyed object of
+ * window entries (`five_hour` / `weekly` / `monthly`, optionally nested under
+ * `usage`) — and reports `unrecognized` instead of guessing when none match.
+ */
+export function parseOpenCodeGoUsage(body) {
+    const windows = [];
+    const push = (id, win) => {
+        if (!id || typeof win !== "object" || win === null || Array.isArray(win))
+            return;
+        windows.push(windowFromEntry(id, win));
+    };
+    const scopes = [body];
+    if (typeof body === "object" && body !== null)
+        scopes.push(body.data);
+    for (const scope of scopes) {
+        if (typeof scope !== "object" || scope === null)
+            continue;
+        const obj = scope;
+        const list = obj.windows;
+        if (Array.isArray(list)) {
+            for (const entry of list) {
+                if (typeof entry !== "object" || entry === null)
+                    continue;
+                const e = entry;
+                const id = WINDOW_ID_KEYS.map((k) => e[k]).find((v) => typeof v === "string" && !!v);
+                push(id ?? `window-${windows.length}`, e);
+            }
+            if (windows.length)
+                return { windows, unrecognized: false };
+        }
+        const usageScope = typeof obj.usage === "object" && obj.usage !== null && !Array.isArray(obj.usage)
+            ? obj.usage
+            : obj;
+        for (const [key, value] of Object.entries(usageScope)) {
+            if (typeof value !== "object" || value === null || Array.isArray(value))
+                continue;
+            const win = value;
+            // Only trust an entry when the KEY names a known window or the object
+            // itself carries explicit window signals (a percent/utilization field
+            // or a reset timestamp). A bare `{ cost: 0.05 }` must not become a row.
+            const keyIsWindow = GO_WINDOW_LABELS[key.toLowerCase().replace(/[-_\s]/g, "")] != null;
+            if (keyIsWindow || windowPct(win) != null || windowResetsAt(win) != null)
+                push(key, win);
+        }
+        if (windows.length)
+            return { windows, unrecognized: false };
+    }
+    return { windows: [], unrecognized: true };
+}
+/**
+ * Fetch opencode Go's rolling usage windows. Throws with a clean message on
+ * any failure — the route maps that to a 502 and the row shows a retryable
+ * error. Unlike OpenRouter there is exactly one endpoint, so there is no
+ * per-part error isolation to preserve.
+ */
+export async function fetchOpenCodeGoUsage(apiKey) {
+    let res;
+    try {
+        res = await fetch(OPENCODE_GO_USAGE_URL, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+    }
+    catch {
+        throw new Error("Could not reach the opencode Go usage API.");
+    }
+    const body = await parseJsonResponse(res, "opencode Go");
+    if (res.status === 401)
+        throw new Error(upstreamError(body, "opencode rejected the API key."));
+    if (res.status >= 400)
+        throw new Error(upstreamError(body, `opencode Go API returned ${res.status}`));
+    return parseOpenCodeGoUsage(body);
+}

package/dist/core/providers/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Provider abstraction for the Model Playground (0313). Each adapter knows
+ * how to turn one external catalog (DeepInfra, OpenRouter, …) into a small
+ * curated list of "worth trying" models with pricing and context window.
+ * Adding a provider is a one-file change: implement `fetchModels` and
+ * register it in `PLAYGROUND_PROVIDERS` (see ./index.ts).
+ */
+/** One model worth trying, enriched with pricing/context from its provider. */
+export interface PlaygroundModel {
+    /** The id as understood by the provider's own API, e.g. "zai-org/GLM-5.3-Flash". */
+    id: string;
+    /** The opencode-runnable id: `${providerId}/${id}`, passed as `--model`. */
+    runId: string;
+    /** Display name. */
+    name: string;
+    /** One-line reason this model is worth trying. */
+    reason: string;
+    /** USD per 1M input tokens, or null when the provider doesn't report it. */
+    inputPricePerM: number | null;
+    /** USD per 1M output tokens, or null when the provider doesn't report it. */
+    outputPricePerM: number | null;
+    /** Context window in tokens, or null when unknown. */
+    contextWindow: number | null;
+}
+/** A per-provider catalog adapter. `fetchModels` should throw on failure — the registry handles caching/fallback. */
+export interface PlaygroundProviderAdapter {
+    /** Stable id, matches the opencode provider prefix (e.g. "deepinfra"). */
+    id: string;
+    /** Display label, e.g. "DeepInfra". */
+    label: string;
+    fetchModels(): Promise<PlaygroundModel[]>;
+}
+/** Result shape served to the client for one provider. */
+export interface PlaygroundProviderGroup {
+    id: string;
+    label: string;
+    models: PlaygroundModel[];
+    /** Set when the live fetch failed and no cached snapshot could cover for it. */
+    error?: string;
+    fetchedAt: string;
+}
+/** Trim a description down to its first sentence for a compact "reason" line. */
+export declare function oneLineReason(description: string | undefined | null, fallback: string): string;
+/**
+ * Parse a fetch `Response` as JSON on behalf of a provider adapter.
+ *
+ * A blocked/rate-limited request often comes back `ok: true` with an HTML
+ * block page instead of the expected JSON body. Calling `res.json()` directly
+ * on that throws a `SyntaxError` whose message embeds a raw snippet of the
+ * HTML (e.g. `Unexpected token '<', "<!DOCTYPE "... is not valid JSON`) — that
+ * snippet then propagates untouched into `PlaygroundProviderGroup.error` and
+ * renders in the sidebar in place of the model list. Checking content-type
+ * first, and falling back to a clean message if parsing still fails, keeps
+ * every error shown to the user readable text instead of a chunk of markup.
+ */
+export declare function parseJsonResponse<T>(res: Response, providerLabel: string): Promise<T>;

package/dist/core/providers/types.js

@@ -0,0 +1,39 @@
+/**
+ * Provider abstraction for the Model Playground (0313). Each adapter knows
+ * how to turn one external catalog (DeepInfra, OpenRouter, …) into a small
+ * curated list of "worth trying" models with pricing and context window.
+ * Adding a provider is a one-file change: implement `fetchModels` and
+ * register it in `PLAYGROUND_PROVIDERS` (see ./index.ts).
+ */
+/** Trim a description down to its first sentence for a compact "reason" line. */
+export function oneLineReason(description, fallback) {
+    const text = (description ?? "").trim();
+    if (!text)
+        return fallback;
+    const firstSentence = text.split(/(?<=[.!?])\s/)[0] ?? text;
+    return firstSentence.length > 140 ? `${firstSentence.slice(0, 137)}...` : firstSentence;
+}
+/**
+ * Parse a fetch `Response` as JSON on behalf of a provider adapter.
+ *
+ * A blocked/rate-limited request often comes back `ok: true` with an HTML
+ * block page instead of the expected JSON body. Calling `res.json()` directly
+ * on that throws a `SyntaxError` whose message embeds a raw snippet of the
+ * HTML (e.g. `Unexpected token '<', "<!DOCTYPE "... is not valid JSON`) — that
+ * snippet then propagates untouched into `PlaygroundProviderGroup.error` and
+ * renders in the sidebar in place of the model list. Checking content-type
+ * first, and falling back to a clean message if parsing still fails, keeps
+ * every error shown to the user readable text instead of a chunk of markup.
+ */
+export async function parseJsonResponse(res, providerLabel) {
+    const contentType = res.headers?.get("content-type") ?? "";
+    if (contentType && !contentType.includes("json")) {
+        throw new Error(`${providerLabel} returned a non-JSON response (${contentType || "unknown content type"})`);
+    }
+    try {
+        return (await res.json());
+    }
+    catch {
+        throw new Error(`${providerLabel} returned a response that could not be parsed as JSON`);
+    }
+}

package/dist/core/repoos.d.ts

@@ -0,0 +1,59 @@
+import { ORIGINAL_PROMPT_HEADING } from "./task.js";
+import { type CommitNewFileResult } from "./git.js";
+import { type RepoOSConfig, type RepoIndex, type Task, type Status } from "./types.js";
+export interface CreateTaskInput {
+    title: string;
+    type?: string;
+    status?: Status;
+    priority?: string;
+    area?: string;
+    assignedTo?: string;
+    createdBy?: string;
+    branch?: string;
+    body?: string;
+    /**
+     * The user's raw freeform prompt. When provided, it is preserved verbatim
+     * under a `## Original prompt` section in the initial body so the user's
+     * capture is never lost, even if a later agent pass rewrites the body.
+     */
+    originalPrompt?: string;
+}
+export { ORIGINAL_PROMPT_HEADING };
+/**
+ * Append the user's raw freeform prompt as a `## Original prompt` section to a
+ * body, unless the section is already present (idempotent). An empty prompt is
+ * left untouched. This keeps the raw capture in the file no matter how a later
+ * agent pass rewrites the rest of the body.
+ */
+export declare function withOriginalPromptSection(body: string, originalPrompt?: string): string;
+export interface RepoOS {
+    config: RepoOSConfig;
+    /** Build a fresh index from the files on disk. */
+    reindex(): RepoIndex;
+    /** All tasks, optionally filtered by status. */
+    getTasks(status?: Status): Task[];
+    /** A single task by id, or null. */
+    getTask(id: string): Task | null;
+    /** Counts per status. */
+    counts(): Record<Status, number>;
+    /**
+     * Change a task's status (frontmatter edit; file stays put). An optional
+     * `note` is appended to the activity log in the same operation.
+     */
+    updateStatus(id: string, status: Status, note?: string): Task;
+    /**
+     * Append a short, free-form note to a task's activity log (see addNote).
+     * The note is recorded as its own activity entry and never rewrites the
+     * task body.
+     */
+    addNote(id: string, note: string): Task;
+    /** Update arbitrary known fields on a task. */
+    updateTask(id: string, patch: Partial<Omit<Task, "git" | "absPath" | "path">>): Task;
+    /** Create a new task file under workDir. Returns the created task. */
+    createTask(input: CreateTaskInput): Task;
+    /** Surgically commit a single new file (fail-soft; never touches other files). */
+    commitNewFile(absPath: string, message: string): CommitNewFileResult;
+}
+export declare function createRepoOS(root?: string): RepoOS;
+export * from "./types.js";
+export { loadConfig, findRepoRoot } from "./config.js";