@repo-os/repoos 0.5.45

package/dist/server/attachments.d.ts

@@ -0,0 +1,51 @@
+import type { RepoOSConfig, Task } from "../core/types.js";
+/** One persisted screenshot, as returned to the client. */
+export interface ScreenshotMeta {
+    /** 1-based index within the task's attachment folder. */
+    id: string;
+    /** Original file name (sanitized). */
+    name: string;
+    /** Repo-relative path, e.g. "work/.attachments/0123/screenshot-1.png". */
+    path: string;
+    /** API URL the UI can load the image from. */
+    url: string;
+    size: number;
+    mime: string;
+}
+/** Image MIME types treated as screenshots, mapped to their file extension. */
+export declare const SCREENSHOT_MIME: Record<string, string>;
+/** Max decoded size for one screenshot upload (bytes). */
+export declare const MAX_SCREENSHOT_BYTES: number;
+export declare function attachmentsDir(root: string, workDir: string, taskId: string): string;
+/** API URL that serves one stored screenshot. */
+export declare function screenshotUrl(taskId: string, file: string): string;
+/** Strip directories and hostile characters from an uploaded file name. */
+export declare function sanitizeName(name: string): string;
+/**
+ * Persist one uploaded screenshot under the task's attachment folder and
+ * return its metadata, or `{ error }` on invalid input. Never throws.
+ */
+export declare function saveScreenshot(config: RepoOSConfig, task: Task, input: {
+    name?: unknown;
+    mime?: unknown;
+    data?: unknown;
+}): ScreenshotMeta | {
+    error: string;
+};
+/**
+ * Insert screenshots into a task body's `## Screenshots` section, keeping it
+ * BEFORE the append-only Activity section so the activity log stays the last
+ * thing in the body. Appends the section at the end when there is no Activity
+ * section. When a Screenshots section already exists (a second upload batch,
+ * or the 0381 pending-batch attach landing on a task that has one), the new
+ * images merge into that section — repeated uploads must not stack duplicate
+ * headings.
+ */
+export declare function appendScreenshotsSection(body: string, metas: ScreenshotMeta[]): string;
+/**
+ * Resolve a stored screenshot to its absolute path, refusing path traversal
+ * outside the task's own attachment folder. Returns null on a miss.
+ */
+export declare function resolveScreenshot(config: RepoOSConfig, taskId: string, file: string): string | null;
+/** MIME type for a stored screenshot file by extension, or null when unknown. */
+export declare function mimeForExtension(file: string): string | null;

package/dist/server/attachments.js

@@ -0,0 +1,130 @@
+/**
+ * Task screenshot attachments (0123).
+ *
+ * Screenshots are uploaded from the New task panel and land in
+ * `<workDir>/.attachments/<taskId>/`, referenced from the task body's
+ * `## Screenshots` section (kept BEFORE the append-only Activity section).
+ * Files are served back through `GET /api/tasks/:id/attachments/:file`.
+ * Dependency-free, mirroring the rest of the server: base64 in JSON in, a
+ * small safe writer for storage.
+ */
+import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, extname, join, resolve, sep } from "node:path";
+import { SCREENSHOTS_HEADING, extractSection, removeSection } from "../core/task.js";
+/** Image MIME types treated as screenshots, mapped to their file extension. */
+export const SCREENSHOT_MIME = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/avif": ".avif",
+    "image/bmp": ".bmp",
+};
+/** Max decoded size for one screenshot upload (bytes). */
+export const MAX_SCREENSHOT_BYTES = 10 * 1024 * 1024;
+export function attachmentsDir(root, workDir, taskId) {
+    return join(root, workDir, ".attachments", taskId);
+}
+/** API URL that serves one stored screenshot. */
+export function screenshotUrl(taskId, file) {
+    return `/api/tasks/${taskId}/attachments/${encodeURIComponent(file)}`;
+}
+/** Strip directories and hostile characters from an uploaded file name. */
+export function sanitizeName(name) {
+    const base = basename(name)
+        .replace(/\.[^./]+$/, "")
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return base || "screenshot";
+}
+/**
+ * Persist one uploaded screenshot under the task's attachment folder and
+ * return its metadata, or `{ error }` on invalid input. Never throws.
+ */
+export function saveScreenshot(config, task, input) {
+    if (typeof input?.name !== "string" ||
+        typeof input?.mime !== "string" ||
+        typeof input?.data !== "string") {
+        return { error: "name, mime, and base64 data are required" };
+    }
+    const ext = SCREENSHOT_MIME[input.mime];
+    if (!ext) {
+        const supported = Object.keys(SCREENSHOT_MIME).join(", ");
+        return { error: `Unsupported image type "${input.mime}" — supported: ${supported}` };
+    }
+    let buf;
+    try {
+        buf = Buffer.from(input.data, "base64");
+    }
+    catch {
+        return { error: "Invalid base64 image data" };
+    }
+    if (buf.length === 0)
+        return { error: "Image data is empty" };
+    if (buf.length > MAX_SCREENSHOT_BYTES) {
+        return {
+            error: `Image is too large (max ${Math.round(MAX_SCREENSHOT_BYTES / 1024 / 1024)} MB)`,
+        };
+    }
+    const dir = attachmentsDir(config.root, config.workDir, task.id);
+    mkdirSync(dir, { recursive: true });
+    const taken = new Set(existsSync(dir) ? readdirSync(dir) : []);
+    let next = 1;
+    while (taken.has(`screenshot-${next}${ext}`))
+        next++;
+    const file = `screenshot-${next}${ext}`;
+    writeFileSync(join(dir, file), buf);
+    return {
+        id: String(next),
+        name: sanitizeName(input.name),
+        path: `${config.workDir.split("\\").join("/")}/.attachments/${task.id}/${file}`,
+        url: screenshotUrl(task.id, file),
+        size: buf.length,
+        mime: input.mime,
+    };
+}
+/**
+ * Insert screenshots into a task body's `## Screenshots` section, keeping it
+ * BEFORE the append-only Activity section so the activity log stays the last
+ * thing in the body. Appends the section at the end when there is no Activity
+ * section. When a Screenshots section already exists (a second upload batch,
+ * or the 0381 pending-batch attach landing on a task that has one), the new
+ * images merge into that section — repeated uploads must not stack duplicate
+ * headings.
+ */
+export function appendScreenshotsSection(body, metas) {
+    const links = metas.map((m) => `![${m.name.replace(/[[\]]/g, "")}](${m.url})`);
+    const trimmed = body.replace(/\s+$/, "");
+    const activityIndex = trimmed.lastIndexOf("\n## Activity\n");
+    const before = activityIndex === -1 ? trimmed : trimmed.slice(0, activityIndex).replace(/\s+$/, "");
+    const after = activityIndex === -1 ? "" : trimmed.slice(activityIndex + 1);
+    const existing = extractSection(before, SCREENSHOTS_HEADING);
+    let next;
+    if (existing !== null) {
+        const without = removeSection(before, SCREENSHOTS_HEADING).replace(/\s+$/, "");
+        next = [without, [existing, ...links].join("\n")].filter(Boolean).join("\n\n");
+    }
+    else {
+        next = [before, ["## Screenshots", "", ...links].join("\n")].filter(Boolean).join("\n\n");
+    }
+    return after ? `${next}\n\n${after}\n` : `${next}\n`;
+}
+/**
+ * Resolve a stored screenshot to its absolute path, refusing path traversal
+ * outside the task's own attachment folder. Returns null on a miss.
+ */
+export function resolveScreenshot(config, taskId, file) {
+    const base = resolve(attachmentsDir(config.root, config.workDir, taskId));
+    const abs = resolve(base, decodeURIComponent(file));
+    if (!abs.startsWith(base + sep))
+        return null;
+    if (!existsSync(abs) || !statSync(abs).isFile())
+        return null;
+    return abs;
+}
+/** Reverse of {@link SCREENSHOT_MIME}: file extension -> MIME type. */
+const EXTENSION_MIME = Object.fromEntries(Object.entries(SCREENSHOT_MIME).map(([mime, ext]) => [ext, mime]));
+/** MIME type for a stored screenshot file by extension, or null when unknown. */
+export function mimeForExtension(file) {
+    return EXTENSION_MIME[extname(file).toLowerCase()] ?? null;
+}

package/dist/server/auto-engineering.d.ts

@@ -0,0 +1,45 @@
+import type { RepoOSConfig, Task } from "../core/types.js";
+/** Result of a reconciliation attempt. */
+export interface ReconciliationResult {
+    triggered: boolean;
+    outcome?: "selected" | "no-capacity" | "no-ready-work" | "pm-unavailable" | "pm-failed";
+    candidateIds?: string[];
+    selectedIds?: string[];
+    rationale?: string;
+    error?: string;
+}
+/** Persisted decision record for Control page hydration. */
+export interface AutoEngineeringDecision {
+    timestamp: string;
+    trigger: "active-to-review" | "inbox-to-ready" | "config-change" | "startup";
+    outcome: ReconciliationResult["outcome"];
+    activeCount: number;
+    maxActiveTasks: number;
+    availableSlots: number;
+    candidateIds: string[];
+    selectedIds: string[];
+    rationale?: string;
+    error?: string;
+}
+/**
+ * Orchestrator for auto-engineering mode. Singleton per server lifetime;
+ * tracks mode state and decision history for Control page display.
+ * Decisions persist to disk for browser refresh recovery.
+ */
+export declare class AutoEngineeringOrchestrator {
+    private lastDecision;
+    private reconciling;
+    private cacheDir;
+    constructor(cacheDir?: string);
+    getLastDecision(): AutoEngineeringDecision | null;
+    /** Store the latest decision for recovery after server restart. */
+    private persistDecision;
+    /** Load the last persisted decision from disk (for browser refresh recovery). */
+    loadPersistedDecision(): void;
+    /**
+     * Check if auto-engineering should trigger: mode enabled, available capacity,
+     * and at least one ready task. Returns early if already reconciling (single-flight).
+     */
+    reconcile(config: RepoOSConfig, allTasks: Task[], trigger: AutoEngineeringDecision["trigger"]): Promise<ReconciliationResult>;
+    private reconcileImpl;
+}

package/dist/server/auto-engineering.js

@@ -0,0 +1,275 @@
+/**
+ * Auto-engineering mode: automatically selects and starts ready tasks up to a
+ * configured maximum. The PM agent decides which tasks are most suitable;
+ * orchestration remains server-owned with proper safeguards against
+ * oversubscription and stale state.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolvePmAgent, runPrompt, recordOneShotSession } from "./agents.js";
+/**
+ * Render the PM prompt for auto-engineering task selection. Receives all
+ * ready tasks and the number of available slots, returns selected task IDs
+ * and brief rationale. The PM never selects more tasks than slots available.
+ */
+function autoEngineeringPrompt(readyTasks, availableSlots) {
+    const tasksList = readyTasks
+        .map((t) => `- **#${t.id}** ${t.title}\n  Type: ${t.type}, Priority: ${t.priority}, Area: ${t.area || "unspecified"}`)
+        .join("\n");
+    return [
+        "You are the PM agent for RepoOS auto-engineering mode. The engineering team has capacity for",
+        `${availableSlots} more task(s). Choose which ready task(s) to start now based on priority,`,
+        "impact, and dependencies.",
+        "",
+        "Ready tasks available:",
+        "",
+        tasksList,
+        "",
+        "Respond with ONLY a JSON object (no preamble, no code fences):",
+        '{"selected": ["0123", "0124"], "rationale": "Starting the most impactful high-priority tasks"}',
+        "",
+        "- `selected`: array of task IDs to start (must not exceed available slots)",
+        "- `rationale`: one-sentence explanation of why these were chosen",
+    ].join("\n");
+}
+/**
+ * Parse the PM agent's structured JSON response. Never throws: anything
+ * unparseable yields an empty selection with an error description.
+ */
+function parseAutoEngineeringSelection(output) {
+    try {
+        const trimmed = output.trim();
+        const obj = JSON.parse(trimmed);
+        if (typeof obj === "object" &&
+            obj !== null &&
+            Array.isArray(obj.selected) &&
+            typeof obj.rationale === "string") {
+            return {
+                selected: obj.selected,
+                rationale: obj.rationale.trim(),
+            };
+        }
+    }
+    catch (e) {
+        // Fall through to error response
+    }
+    return {
+        selected: [],
+        rationale: "",
+        error: "PM response was not valid JSON or missing required fields",
+    };
+}
+/**
+ * Orchestrator for auto-engineering mode. Singleton per server lifetime;
+ * tracks mode state and decision history for Control page display.
+ * Decisions persist to disk for browser refresh recovery.
+ */
+export class AutoEngineeringOrchestrator {
+    lastDecision = null;
+    reconciling = false;
+    cacheDir;
+    constructor(cacheDir) {
+        this.cacheDir = cacheDir ?? ".repoos";
+    }
+    getLastDecision() {
+        return this.lastDecision;
+    }
+    /** Store the latest decision for recovery after server restart. */
+    persistDecision(decision) {
+        try {
+            const filePath = join(this.cacheDir, "auto-engineering-decision.json");
+            mkdirSync(this.cacheDir, { recursive: true });
+            writeFileSync(filePath, JSON.stringify(decision, null, 2));
+        }
+        catch {
+            // Persistence is best-effort — failures don't block reconciliation
+        }
+    }
+    /** Load the last persisted decision from disk (for browser refresh recovery). */
+    loadPersistedDecision() {
+        try {
+            const filePath = join(this.cacheDir, "auto-engineering-decision.json");
+            if (existsSync(filePath)) {
+                const data = readFileSync(filePath, "utf8");
+                this.lastDecision = JSON.parse(data);
+            }
+        }
+        catch {
+            // Load failure is silent — just start with no persisted state
+        }
+    }
+    /**
+     * Check if auto-engineering should trigger: mode enabled, available capacity,
+     * and at least one ready task. Returns early if already reconciling (single-flight).
+     */
+    async reconcile(config, allTasks, trigger) {
+        if (this.reconciling) {
+            return { triggered: false };
+        }
+        const enabled = config.autoEngineeringMode ?? false;
+        if (!enabled) {
+            return { triggered: false };
+        }
+        this.reconciling = true;
+        try {
+            return await this.reconcileImpl(config, allTasks, trigger);
+        }
+        finally {
+            this.reconciling = false;
+        }
+    }
+    async reconcileImpl(config, allTasks, trigger) {
+        const maxActiveTasks = config.maxActiveTasks ?? 3;
+        const activeCount = allTasks.filter((t) => t.status === "active").length;
+        const availableSlots = Math.max(0, maxActiveTasks - activeCount);
+        // No capacity available.
+        if (availableSlots === 0) {
+            this.lastDecision = {
+                timestamp: new Date().toISOString(),
+                trigger,
+                outcome: "no-capacity",
+                activeCount,
+                maxActiveTasks,
+                availableSlots,
+                candidateIds: [],
+                selectedIds: [],
+            };
+            this.persistDecision(this.lastDecision);
+            return {
+                triggered: true,
+                outcome: "no-capacity",
+            };
+        }
+        const readyTasks = allTasks.filter((t) => t.status === "ready");
+        // No ready tasks.
+        if (readyTasks.length === 0) {
+            this.lastDecision = {
+                timestamp: new Date().toISOString(),
+                trigger,
+                outcome: "no-ready-work",
+                activeCount,
+                maxActiveTasks,
+                availableSlots,
+                candidateIds: [],
+                selectedIds: [],
+            };
+            this.persistDecision(this.lastDecision);
+            return {
+                triggered: true,
+                outcome: "no-ready-work",
+            };
+        }
+        const pm = resolvePmAgent(config);
+        if (!pm) {
+            this.lastDecision = {
+                timestamp: new Date().toISOString(),
+                trigger,
+                outcome: "pm-unavailable",
+                activeCount,
+                maxActiveTasks,
+                availableSlots,
+                candidateIds: readyTasks.map((t) => t.id),
+                selectedIds: [],
+                error: "PM agent is not configured or enabled",
+            };
+            this.persistDecision(this.lastDecision);
+            return {
+                triggered: true,
+                outcome: "pm-unavailable",
+                error: "PM agent is not configured or enabled",
+            };
+        }
+        // Invoke PM agent to select which ready tasks to start.
+        const prompt = autoEngineeringPrompt(readyTasks, availableSlots);
+        let pmResult;
+        try {
+            pmResult = await runPrompt(pm, prompt, {
+                cwd: config.root,
+            });
+        }
+        catch (e) {
+            const error = `PM agent failed: ${e instanceof Error ? e.message : String(e)}`;
+            this.lastDecision = {
+                timestamp: new Date().toISOString(),
+                trigger,
+                outcome: "pm-failed",
+                activeCount,
+                maxActiveTasks,
+                availableSlots,
+                candidateIds: readyTasks.map((t) => t.id),
+                selectedIds: [],
+                error,
+            };
+            this.persistDecision(this.lastDecision);
+            return {
+                triggered: true,
+                outcome: "pm-failed",
+                error,
+            };
+        }
+        // Board-level PM spend — the dispatch pass belongs to no single task (0311).
+        recordOneShotSession(config.root, pm, pmResult, { sessionType: "dispatch", taskId: null });
+        if (!pmResult.ok || !pmResult.output) {
+            const error = pmResult.error || "PM agent returned no output";
+            this.lastDecision = {
+                timestamp: new Date().toISOString(),
+                trigger,
+                outcome: "pm-failed",
+                activeCount,
+                maxActiveTasks,
+                availableSlots,
+                candidateIds: readyTasks.map((t) => t.id),
+                selectedIds: [],
+                error,
+            };
+            this.persistDecision(this.lastDecision);
+            return {
+                triggered: true,
+                outcome: "pm-failed",
+                error,
+            };
+        }
+        const selection = parseAutoEngineeringSelection(pmResult.output);
+        if (selection.error) {
+            this.lastDecision = {
+                timestamp: new Date().toISOString(),
+                trigger,
+                outcome: "pm-failed",
+                activeCount,
+                maxActiveTasks,
+                availableSlots,
+                candidateIds: readyTasks.map((t) => t.id),
+                selectedIds: [],
+                error: selection.error,
+            };
+            this.persistDecision(this.lastDecision);
+            return {
+                triggered: true,
+                outcome: "pm-failed",
+                error: selection.error,
+            };
+        }
+        // Validate selection: ensure all IDs exist in ready pool and don't exceed slots.
+        const readySet = new Set(readyTasks.map((t) => t.id));
+        const validated = selection.selected.filter((id) => readySet.has(id)).slice(0, availableSlots);
+        this.lastDecision = {
+            timestamp: new Date().toISOString(),
+            trigger,
+            outcome: "selected",
+            activeCount,
+            maxActiveTasks,
+            availableSlots,
+            candidateIds: readyTasks.map((t) => t.id),
+            selectedIds: validated,
+            rationale: selection.rationale,
+        };
+        this.persistDecision(this.lastDecision);
+        return {
+            triggered: true,
+            outcome: "selected",
+            candidateIds: readyTasks.map((t) => t.id),
+            selectedIds: validated,
+            rationale: selection.rationale,
+        };
+    }
+}

package/dist/server/branchless-release.d.ts

@@ -0,0 +1,22 @@
+import type { RepoOSConfig, Task } from "../core/types.js";
+export interface CheckResult {
+    ok: boolean;
+    /** Tail of combined stdout+stderr on failure, for the caller to surface. */
+    output?: string;
+}
+/** Real check runner: prefers the local build's own CLI, same preference order as the close-out pipeline. */
+export declare function runCheckOnRoot(root: string): CheckResult;
+export interface ReleaseBranchlessResult {
+    ok: boolean;
+    reason?: string;
+    task?: Task;
+}
+/**
+ * A task is eligible for this path when it has no branch and isn't already
+ * done. `review`-status is deliberately excluded even if branchless — that
+ * shape shouldn't occur (nothing sets `review` without a branch), and if it
+ * ever does, the normal `/done` merge path's own guard is the one that
+ * should reject it, not this one silently swallowing it.
+ */
+export declare function isBranchlessReleaseEligible(task: Task): boolean;
+export declare function releaseBranchless(config: RepoOSConfig, task: Task, runCheck?: (root: string) => CheckResult): Promise<ReleaseBranchlessResult>;

package/dist/server/branchless-release.js

@@ -0,0 +1,67 @@
+/**
+ * Release a branch-less task directly, skipping the branch-merge close-out
+ * pipeline entirely.
+ *
+ * A task fixed by a direct commit on `main` (a hotfix — see #0212, not yet a
+ * first-class flow) has nothing to merge: its code is already on `main`.
+ * Routing it through the normal `/done` pipeline dead-ends on "no branch to
+ * merge" — not because the task isn't done, but because that pipeline is
+ * built entirely around merging a branch. This is the separate path: verify
+ * `main` is currently green, then release directly via `markTaskReleased`.
+ *
+ * Never touches the job queue or the repository lock — there is no merge to
+ * serialize against other close-outs, so those mechanisms don't apply.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { markTaskReleased } from "./write.js";
+/** Real check runner: prefers the local build's own CLI, same preference order as the close-out pipeline. */
+export function runCheckOnRoot(root) {
+    const localCli = join(root, "dist", "cli", "index.js");
+    const candidates = existsSync(localCli)
+        ? [
+            [process.execPath, localCli, "check"],
+            ["repoos", "check"],
+        ]
+        : [
+            ["repoos", "check"],
+            ["bun", "run", "repoos", "check"],
+        ];
+    let last = null;
+    for (const [cmd, ...args] of candidates) {
+        const r = spawnSync(cmd, args, { cwd: root, encoding: "utf8", timeout: 600_000 });
+        last = r;
+        if (r.status === 0)
+            return { ok: true };
+    }
+    const output = [last?.stdout, last?.stderr]
+        .filter((x) => typeof x === "string" && x.trim() !== "")
+        .join("\n")
+        .trim()
+        .split("\n")
+        .slice(-15)
+        .join("\n");
+    return { ok: false, output: output || "no output captured" };
+}
+/**
+ * A task is eligible for this path when it has no branch and isn't already
+ * done. `review`-status is deliberately excluded even if branchless — that
+ * shape shouldn't occur (nothing sets `review` without a branch), and if it
+ * ever does, the normal `/done` merge path's own guard is the one that
+ * should reject it, not this one silently swallowing it.
+ */
+export function isBranchlessReleaseEligible(task) {
+    return !task.branch && task.status !== "done" && task.status !== "review";
+}
+export async function releaseBranchless(config, task, runCheck = runCheckOnRoot) {
+    const check = runCheck(config.root);
+    if (!check.ok) {
+        return {
+            ok: false,
+            reason: `repoos check failed on main — cannot release a branch-less task until main is green: ${check.output ?? ""}`,
+        };
+    }
+    const task_ = markTaskReleased(config, task.absPath);
+    return { ok: true, task: task_ };
+}