@repo-os/repoos 0.5.45

package/dist/server/routes/debugger.js

@@ -0,0 +1,360 @@
+import { json, readBody } from "./utils.js";
+import { debuggerAgent, debuggerSessionId, deriveBranch, resolveAgentForTask, resolvePmAgent, taskPmPrompt, } from "../agents.js";
+import { patchTaskFile } from "../write.js";
+import { getCurrentUser } from "./auth.js";
+import { ensureWorktree } from "../../core/git.js";
+import { bootstrap } from "../../core/bootstrap.js";
+import { generateContextPack, resumePreamble } from "../../core/context-pack.js";
+export const getDebugger = (ctx, _req, res) => {
+    const { config, runner } = ctx;
+    const state = config.builtInAgents?.debugger ?? {};
+    const enabled = Boolean(state.enabled);
+    const session = runner.output(debuggerSessionId);
+    return json(res, 200, {
+        ok: true,
+        agent: debuggerAgent(fromPersisted(state)),
+        enabled,
+        lines: session?.lines ?? [],
+        running: runner.isRunning(debuggerSessionId),
+        stats: runner.stats(debuggerSessionId),
+    });
+};
+/** Persisted cli/model overrides for the Debugger, sanitized to non-empty strings. */
+function fromPersisted(state) {
+    const cli = typeof state.cli === "string" && state.cli.trim() ? state.cli.trim() : undefined;
+    const model = typeof state.model === "string" && state.model.trim() ? state.model.trim() : undefined;
+    return { cli, model };
+}
+export const sendDebuggerMessage = async (ctx, req, res) => {
+    const { config, index, runner } = ctx;
+    const state = config.builtInAgents?.debugger ?? {};
+    if (!state.enabled) {
+        return json(res, 400, {
+            error: "Debugger is disabled — enable it on the Agents page to chat",
+        });
+    }
+    const body = (await readBody(req));
+    const text = typeof body?.text === "string" ? body.text.trim() : "";
+    if (!text)
+        return json(res, 400, { error: "message text is required" });
+    const agent = debuggerAgent(fromPersisted(state));
+    const context = repoContextForDebugger(index);
+    const existing = runner.output(debuggerSessionId);
+    const result = existing
+        ? runner.send(debuggerSessionId, text, agent, {
+            resumePreamble: `Updated repository context:\n${context}`,
+        })
+        : runner.startChat(debuggerSessionId, text, agent, context);
+    if (!result.ok) {
+        const reason = result.reason ?? "could not send message";
+        // Both a busy turn (`busy`) and the concurrency race where another request
+        // created the session between the output check above and startChat
+        // ("conversation already exists") mean the conversation is in flight — the
+        // caller should surface a retry, not a hard failure.
+        if (result.busy || reason.includes("already exists")) {
+            return json(res, 409, {
+                error: "Debugger is busy — wait for the current turn to finish",
+            });
+        }
+        return json(res, 400, { error: reason });
+    }
+    return json(res, 200, { ok: true });
+};
+/** Interrupt a running Debugger response. Idempotent. */
+export const interruptDebugger = (ctx, _req, res) => {
+    const result = ctx.runner.interrupt(debuggerSessionId);
+    return json(res, 200, { ok: true, ...result });
+};
+/** Hand an explicit debugger diagnosis to the task's existing engineering session. */
+export const repairWithDebugger = async (ctx, req, res) => {
+    const { config, index, runner } = ctx;
+    const body = (await readBody(req));
+    const taskId = typeof body.taskId === "string" ? body.taskId : "";
+    const diagnosis = typeof body.diagnosis === "string" ? body.diagnosis.trim() : "";
+    const task = index.getTask(taskId);
+    if (!task)
+        return json(res, 404, { error: "Task not found" });
+    if (task.status !== "review")
+        return json(res, 400, { error: "Only review tasks can be repaired" });
+    if (!diagnosis)
+        return json(res, 400, { error: "Debugger diagnosis is required" });
+    const engineer = resolveAgentForTask(config, task);
+    if (!engineer)
+        return json(res, 400, { error: "No enabled engineer is configured" });
+    const sent = runner.send(task.id, [
+        "The Debugger diagnosed a failed Move-to-done operation. Apply the smallest safe repair in this existing worktree, run repoos check, then hand off to review.",
+        diagnosis,
+    ].join("\n\n"), engineer, { skipBoardDivergence: true });
+    if (!sent.ok)
+        return json(res, sent.busy ? 409 : 400, { error: sent.reason ?? "Could not start engineer" });
+    const updated = patchTaskFile(config, task.absPath, { status: "active" });
+    index.applyFileChange(updated.absPath);
+    return json(res, 200, { ok: true, task: index.getTask(task.id) });
+};
+/** Minimal repository context for the Debugger (bug paste vs. config surface). */
+function repoContextForDebugger(index) {
+    const tasks = index.getTasks();
+    const lines = tasks.map((t) => `#${t.id} ${t.title} (${t.status})`);
+    return [
+        `RepoOS repository with ${tasks.length} task(s).`,
+        ...(lines.length ? lines : ["No tasks yet."]),
+    ].join("\n");
+}
+/**
+ * Per-task Debugger chat (task #0337). The session is keyed by
+ * `debugger:<taskId>` so it lives alongside — but does not collide with — the
+ * global bug-paste Debugger (`__repoos-debugger__`) and the task's own
+ * engineer/PM/reviewer sessions.
+ */
+export const taskDebuggerSessionId = (taskId) => `debugger:${taskId}`;
+/**
+ * Redact obvious secrets/credentials from text before it is handed to the
+ * Debugger. The agent is instructed never to surface secrets too, but defense
+ * in depth: a stray API key or password in a log line should never reach the
+ * model's prompt (and therefore the user's screen).
+ */
+function redactSecrets(text) {
+    return text
+        .replace(/sk-[A-Za-z0-9_-]{20,}/g, "***REDACTED***")
+        .replace(/AKIA[0-9A-Z]{16}/g, "***REDACTED***")
+        .replace(/gh[pousr]_[A-Za-z0-9]{20,}/g, "***REDACTED***")
+        .replace(/\bBearer\s+[A-Za-z0-9._\-]+/gi, "Bearer ***REDACTED***")
+        .replace(/\b(api[_-]?key|apikey|secret|access[_-]?token|auth[_-]?token|client[_-]?secret|private[_-]?key|password|passwd|token)\b\s*[:=]\s*['"]?[^\s'"`}]{6,}/gi, (m) => {
+        const eq = m.match(/[:=]\s*['"]?/);
+        const sep = eq ? eq[0] : ": ";
+        const key = m.slice(0, m.length - (eq ? eq[0].length : 0));
+        return `${key}${sep}***REDACTED***`;
+    });
+}
+/** Render one agent transcript entry to a single-line-ish readable string. */
+function entryText(e) {
+    if ("type" in e) {
+        switch (e.type) {
+            case "human":
+                return `User: ${e.text}`;
+            case "text":
+                return `Assistant: ${e.text}`;
+            case "sys":
+                return `[system] ${e.d}`;
+            case "tool": {
+                const input = e.input ? `\n    input: ${e.input}` : "";
+                const output = e.output ? `\n    output: ${e.output}` : "";
+                const state = e.state ? ` (${e.state})` : "";
+                return `[tool ${e.tool}${state}]${input}${output}`;
+            }
+            case "step":
+                return "";
+            default:
+                return "";
+        }
+    }
+    return e.s === "sys" ? `[system] ${e.d}` : e.d;
+}
+function transcriptFor(label, session) {
+    if (!session || !session.lines || session.lines.length === 0) {
+        return `(${label}: no conversation yet)`;
+    }
+    return session.lines.map(entryText).filter(Boolean).join("\n");
+}
+/**
+ * Aggregate the full task context the Debugger reasons over: the task's
+ * metadata/body, every agent conversation thread (engineer/developer, PM,
+ * reviewer), and the task's own logs. Secrets are redacted before returning.
+ */
+function buildTaskDebuggerContext(ctx, taskId, currentUserEmail) {
+    const task = ctx.index.getTask(taskId);
+    if (!task)
+        return "(task not found)";
+    const parts = [];
+    parts.push(`# Task #${task.id}: ${task.title}`);
+    parts.push(`Status: ${task.status} | Priority: ${task.priority ?? "unset"} | Area: ${task.area ?? "unset"} | Type: ${task.type ?? "unset"}`);
+    if (task.branch)
+        parts.push(`Branch: ${task.branch}`);
+    if (task.body)
+        parts.push(`\n## Task specification\n${task.body}`);
+    const logs = ctx.logger.getTaskLogs(taskId, 800);
+    if (logs.length) {
+        const rendered = logs
+            .map((l) => `[${l.timestamp}] ${l.level}: ${l.message}${l.context ? " " + JSON.stringify(l.context) : ""}`)
+            .join("\n");
+        parts.push(`\n## Task logs (most recent first)\n${rendered}`);
+    }
+    parts.push(`\n## Engineer (developer) conversation\n${transcriptFor("engineer", ctx.runner.output(task.id))}`);
+    const pmSessionId = currentUserEmail
+        ? `pm-task-v2:${task.id}::${currentUserEmail}`
+        : `pm-task-v2:${task.id}`;
+    parts.push(`\n## PM (product manager) conversation\n${transcriptFor("PM", ctx.runner.output(pmSessionId))}`);
+    parts.push(`\n## Reviewer conversation\n${transcriptFor("reviewer", ctx.runner.output(`review:${task.id}`))}`);
+    return redactSecrets(parts.join("\n"));
+}
+/** Read the Debugger's enabled state for a specific task's debug chat. */
+export const getTaskDebugger = (ctx, _req, res, params) => {
+    const id = params.param1;
+    const task = ctx.index.getTask(id);
+    if (!task)
+        return json(res, 404, { error: `Task #${id} not found` });
+    const state = ctx.config.builtInAgents?.debugger ?? {};
+    const enabled = Boolean(state.enabled);
+    const sessionId = taskDebuggerSessionId(id);
+    const session = ctx.runner.output(sessionId);
+    return json(res, 200, {
+        ok: true,
+        enabled,
+        lines: session?.lines ?? [],
+        running: ctx.runner.isRunning(sessionId),
+    });
+};
+/** Start or continue a task-scoped Debugger conversation with full context. */
+export const sendTaskDebuggerMessage = async (ctx, req, res, params) => {
+    const { config, index, runner } = ctx;
+    const id = params.param1;
+    const state = config.builtInAgents?.debugger ?? {};
+    if (!state.enabled) {
+        return json(res, 400, {
+            error: "Debugger is disabled — enable it on the Agents page to chat",
+        });
+    }
+    const task = index.getTask(id);
+    if (!task)
+        return json(res, 404, { error: `Task #${id} not found` });
+    const body = (await readBody(req));
+    const text = typeof body?.text === "string" ? body.text.trim() : "";
+    if (!text)
+        return json(res, 400, { error: "message text is required" });
+    const agent = debuggerAgent(fromPersisted(state));
+    const currentUserEmail = getCurrentUser(req, config)?.email;
+    const context = buildTaskDebuggerContext(ctx, id, currentUserEmail);
+    const sessionId = taskDebuggerSessionId(id);
+    const existing = runner.output(sessionId);
+    const result = existing
+        ? runner.send(sessionId, text, agent, {
+            resumePreamble: `Latest task context:\n${context}`,
+        })
+        : runner.startChat(sessionId, text, agent, context);
+    if (!result.ok) {
+        if (result.busy) {
+            return json(res, 409, { error: "Debugger is busy — wait for the current turn to finish" });
+        }
+        return json(res, 400, { error: result.reason ?? "could not send message" });
+    }
+    return json(res, 200, { ok: true });
+};
+/** Interrupt a running task-scoped Debugger response. Idempotent. */
+export const interruptTaskDebugger = (ctx, _req, res, params) => {
+    const result = ctx.runner.interrupt(taskDebuggerSessionId(params.param1));
+    return json(res, 200, { ok: true, ...result });
+};
+/**
+ * Dispatch a follow-up instruction from the task Debugger chat straight to the
+ * engineer: resume the task's existing engineering session with the instruction,
+ * or start the engineer fresh when it has never run. Sets the task `active` so
+ * the agent can act on the diagnosis.
+ */
+export const sendTaskDebuggerToEngineer = async (ctx, req, res, params) => {
+    const { config, index, runner, onServerStatusChange } = ctx;
+    const id = params.param1;
+    const task = index.getTask(id);
+    if (!task)
+        return json(res, 404, { error: `Task #${id} not found` });
+    const body = (await readBody(req));
+    const text = typeof body?.text === "string" ? body.text.trim() : "";
+    if (!text)
+        return json(res, 400, { error: "instruction text is required" });
+    const engineer = resolveAgentForTask(config, task);
+    if (!engineer) {
+        return json(res, 400, { error: "No enabled engineer agent is configured on the Agents page" });
+    }
+    const existing = runner.output(id);
+    if (existing) {
+        if (task.status !== "active") {
+            const updated = patchTaskFile(config, task.absPath, { status: "active" });
+            index.applyFileChange(updated.absPath);
+        }
+        const sent = runner.send(id, text, engineer, { skipBoardDivergence: true });
+        if (!sent.ok) {
+            return json(res, sent.busy ? 409 : 400, { error: sent.reason ?? "Could not reach engineer" });
+        }
+        return json(res, 200, { ok: true, task: index.getTask(id) });
+    }
+    // Engineer never ran for this task — boot it fresh with the instruction.
+    if (task.status !== "ready" && task.status !== "active") {
+        return json(res, 400, {
+            error: `Only ready or active tasks can be started (#${id} is ${task.status})`,
+        });
+    }
+    if (runner.isRunning(id)) {
+        return json(res, 400, { error: `Task #${id} is already running` });
+    }
+    const branch = task.branch || deriveBranch(task.title);
+    const patch = { status: "active", needsInput: false };
+    if (!task.branch)
+        patch.branch = branch;
+    const updated = patchTaskFile(config, task.absPath, patch, {
+        onStatusChange: onServerStatusChange,
+    });
+    const wtRes = ensureWorktree(config.root, branch);
+    index.applyFileChange(updated.absPath);
+    index.refreshBranches();
+    const cwd = wtRes.ok ? wtRes.path : config.root;
+    const taskForLaunch = index.getTask(updated.id) ?? updated;
+    const bootResult = await bootstrap(config, taskForLaunch, branch, cwd);
+    if (!bootResult.ok) {
+        return json(res, 500, { error: `Bootstrap failed: ${bootResult.reason ?? "unknown error"}` });
+    }
+    const pack = generateContextPack(config, taskForLaunch, branch, cwd, bootResult);
+    const resumeContext = !task.branch || !wtRes.ok ? undefined : resumePreamble(config, taskForLaunch, branch, cwd);
+    const preamble = [resumeContext, text].filter(Boolean).join("\n\n") || undefined;
+    const spawnRes = runner.start(taskForLaunch, branch, engineer, {
+        cwd,
+        contextPack: pack.content,
+        resumePreamble: preamble,
+    });
+    return json(res, 200, {
+        ok: true,
+        task: index.getTask(updated.id),
+        branch,
+        spawn: { ok: spawnRes.ok, pid: spawnRes.pid, queued: spawnRes.queued, reason: spawnRes.reason },
+    });
+};
+/**
+ * Dispatch a follow-up instruction from the task Debugger chat to the PM. Opens
+ * (or resumes) the task's PM conversation with the instruction and the full
+ * task context, so the PM can update the task on the diagnosis.
+ */
+export const sendTaskDebuggerToPm = async (ctx, req, res, params) => {
+    const { config, index, runner } = ctx;
+    const id = params.param1;
+    const existing = index.getTask(id);
+    if (!existing)
+        return json(res, 404, { error: `Task #${id} not found` });
+    const body = (await readBody(req));
+    const text = typeof body?.text === "string" ? body.text.trim() : "";
+    if (!text)
+        return json(res, 400, { error: "instruction text is required" });
+    const pm = resolvePmAgent(config);
+    if (!pm) {
+        return json(res, 400, { error: "PM agent is not configured — enable it on the Agents page" });
+    }
+    const currentUserEmail = getCurrentUser(req, config)?.email;
+    const pmSessionId = currentUserEmail
+        ? `pm-task-v2:${id}::${currentUserEmail}`
+        : `pm-task-v2:${id}`;
+    const taskContext = `Task #${id}: ${existing.title}
+Status: ${existing.status}
+Priority: ${existing.priority || "unset"}
+Area: ${existing.area || "unset"}
+Type: ${existing.type || "unset"}
+
+Description:
+${existing.body || "(no description)"}`;
+    const result = runner.output(pmSessionId)
+        ? runner.send(pmSessionId, text, pm, { resumePreamble: `Task context:\n${taskContext}` })
+        : runner.startChat(pmSessionId, text, pm, taskContext, taskPmPrompt);
+    if (!result.ok && result.busy) {
+        return json(res, 409, { error: result.reason ?? "PM is busy" });
+    }
+    if (!result.ok) {
+        return json(res, 400, { error: result.reason ?? "could not send message to PM" });
+    }
+    return json(res, 200, { ok: true });
+};

package/dist/server/routes/deployments.d.ts

@@ -0,0 +1,3 @@
+import type { RouteHandler } from "./types.js";
+export declare const getDeployments: RouteHandler;
+export declare const postDeploy: RouteHandler;

package/dist/server/routes/deployments.js

@@ -0,0 +1,16 @@
+import { json, readBody } from "./utils.js";
+import { deployBranch, getDeploymentsStatus } from "../deployments.js";
+export const getDeployments = async (ctx, _req, res) => json(res, 200, await getDeploymentsStatus(ctx.config));
+export const postDeploy = async (ctx, req, res) => {
+    const body = (await readBody(req));
+    if (typeof body.branch !== "string" || !body.branch.trim())
+        return json(res, 400, { error: "branch is required" });
+    const result = await deployBranch(ctx.config, body.branch.trim());
+    // 409 (not 400) for the refusal cases: the request was well-formed but the
+    // repository state — dirty tree, diverged branches, moved remote — refused it.
+    // The refusal text is ALSO carried in `error`, not just `output`: the
+    // browser's api() wrapper only surfaces `body.error`/`body.reason` on a
+    // non-2xx, so without this the carefully-assembled git refusal ("Nothing
+    // was force-pushed", git's stderr) would reach the user as "Conflict".
+    return json(res, result.ok ? 200 : 409, { ...result, error: result.output });
+};

package/dist/server/routes/docs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Document routes: manual create + PM-agent-backed freeform create.
+ */
+import type { RouteHandler } from "./types.js";
+export declare const createDoc: RouteHandler;
+export declare const createSkillRoute: RouteHandler;
+export declare const createFreeformSkillRoute: RouteHandler;
+export declare const createFreeformDoc: RouteHandler;

package/dist/server/routes/docs.js

@@ -0,0 +1,135 @@
+import { json, readBody } from "./utils.js";
+import { resolvePmAgent, runPrompt, recordOneShotSession } from "../agents.js";
+/** Apply optional `cliOverride` / `modelOverride` from a request body onto the base PM agent. */
+function pmWithOverrides(base, body) {
+    const cli = typeof body?.cliOverride === "string" && body.cliOverride ? body.cliOverride : undefined;
+    const model = typeof body?.modelOverride === "string" && body.modelOverride ? body.modelOverride : undefined;
+    return { ...base, ...(cli ? { cli } : {}), ...(model ? { model } : {}) };
+}
+import { createDocument, createFreeformDocument, createSkill, createFreeformSkill, docFreeformPrompt, skillFreeformPrompt, parseGeneratedDocument, } from "../../core/docs.js";
+export const createDoc = async (ctx, req, res) => {
+    const { config } = ctx;
+    const body = (await readBody(req));
+    // `content` is a utf8 string (manual create, text upload); `contentBase64` is
+    // base64-encoded raw bytes (binary upload — images, PDFs, fonts).
+    const isBase64 = typeof body.contentBase64 === "string";
+    const content = isBase64 ? body.contentBase64 : body.content;
+    if (typeof content !== "string") {
+        return json(res, 400, { error: "content or contentBase64 is required" });
+    }
+    try {
+        const result = createDocument(config, {
+            path: body.path,
+            content,
+            encoding: isBase64 ? "base64" : "utf8",
+        });
+        return json(res, 201, { ok: true, path: result.path });
+    }
+    catch (err) {
+        return json(res, 400, { error: err.message });
+    }
+};
+export const createSkillRoute = async (ctx, req, res) => {
+    const { config } = ctx;
+    const body = (await readBody(req));
+    const name = typeof body.name === "string" ? body.name.trim() : "";
+    if (!name) {
+        return json(res, 400, { error: "name is required" });
+    }
+    try {
+        const result = createSkill(config, {
+            name,
+            description: typeof body.description === "string" ? body.description : "",
+            body: typeof body.body === "string" ? body.body : "",
+            content: typeof body.content === "string" ? body.content : undefined,
+        });
+        return json(res, 201, { ok: true, path: result.path });
+    }
+    catch (err) {
+        return json(res, 400, { error: err.message });
+    }
+};
+export const createFreeformSkillRoute = async (ctx, req, res) => {
+    const { config, emitEvent } = ctx;
+    const body = (await readBody(req));
+    const description = typeof body?.description === "string" ? body.description.trim() : "";
+    if (!description) {
+        return json(res, 400, { ok: false, reason: "description is required" });
+    }
+    const runId = typeof body?.runId === "string" && body.runId ? body.runId : null;
+    const pmBase = resolvePmAgent(config);
+    if (!pmBase) {
+        return json(res, 400, { ok: false, reason: "No PM agent is configured" });
+    }
+    const pm = pmWithOverrides(pmBase, body);
+    try {
+        const skillResult = await createFreeformSkill(config, description, async (desc) => {
+            const result = await runPrompt(pm, skillFreeformPrompt(desc), {
+                cwd: config.root,
+                onLine: runId
+                    ? (line) => {
+                        emitEvent({
+                            type: "agent.output",
+                            id: runId,
+                            entry: { s: "out", d: line },
+                            stream: "out",
+                            at: new Date().toISOString(),
+                        });
+                    }
+                    : undefined,
+            });
+            recordOneShotSession(config.root, pm, result, { sessionType: "pm", taskId: null });
+            if (!result.ok || !result.output) {
+                throw new Error(result.error ?? "the PM agent returned no usable output");
+            }
+            return parseGeneratedDocument(result.output);
+        });
+        return json(res, 201, { ok: true, path: skillResult.path });
+    }
+    catch (err) {
+        return json(res, 400, { ok: false, reason: err.message });
+    }
+};
+export const createFreeformDoc = async (ctx, req, res) => {
+    const { config, emitEvent } = ctx;
+    const body = (await readBody(req));
+    const description = typeof body?.description === "string" ? body.description.trim() : "";
+    if (!description) {
+        return json(res, 400, { ok: false, reason: "description is required" });
+    }
+    const runId = typeof body?.runId === "string" && body.runId ? body.runId : null;
+    const pmBase = resolvePmAgent(config);
+    if (!pmBase) {
+        return json(res, 400, { ok: false, reason: "No PM agent is configured" });
+    }
+    // The New doc panel sends cliOverride / modelOverride from its agent picker.
+    const pm = pmWithOverrides(pmBase, body);
+    try {
+        const docResult = await createFreeformDocument(config, description, async (desc) => {
+            const result = await runPrompt(pm, docFreeformPrompt(desc), {
+                cwd: config.root,
+                onLine: runId
+                    ? (line) => {
+                        emitEvent({
+                            type: "agent.output",
+                            id: runId,
+                            entry: { s: "out", d: line },
+                            stream: "out",
+                            at: new Date().toISOString(),
+                        });
+                    }
+                    : undefined,
+            });
+            // Freeform doc authoring is real PM spend that belongs to no task (0311).
+            recordOneShotSession(config.root, pm, result, { sessionType: "pm", taskId: null });
+            if (!result.ok || !result.output) {
+                throw new Error(result.error ?? "the PM agent returned no usable output");
+            }
+            return parseGeneratedDocument(result.output);
+        });
+        return json(res, 201, { ok: true, path: docResult.path });
+    }
+    catch (err) {
+        return json(res, 400, { ok: false, reason: err.message });
+    }
+};

package/dist/server/routes/helpers.d.ts

@@ -0,0 +1,21 @@
+import type { RepoOSConfig, Task } from "../../core/types.js";
+export declare const UI_MIME: Record<string, string>;
+export declare function serveStaticUi(res: any, uiDir: string, urlPath: string): boolean;
+export declare function safeRepoFile(root: string, urlPath: string): string | null;
+export declare function findUiDir(root: string): string | null;
+export declare function findPackageRoot(): string | null;
+export declare function loadBuildInfo(): {
+    version: string | null;
+    buildAt: string | null;
+};
+export declare function skillField(text: string, field: string): string | null;
+export declare function listDocs(config: RepoOSConfig): {
+    path: string;
+    title: string;
+}[];
+export declare function listSkills(config: RepoOSConfig): {
+    path: string;
+    name: string;
+    description: string;
+}[];
+export declare function repoGuideContext(config: RepoOSConfig, tasks: Task[]): string;