@repo-os/repoos 0.5.68 → 0.5.70

package/dist/.build-info.json

@@ -1,5 +1,5 @@
 {
-  "hash": "a50a11bbcdcbcbedd23ed2410aa902333da0a7c6a5f48a204f67758d061c71d1",
-  "version": "0.5.68",
+  "hash": "131590b8131d68f048a4d4d6050b17a4912fd3b3967d60ed47aa4d04a93f235c",
+  "version": "0.5.70",
   "devUi": false
 }

package/dist/.build-stamp.json

@@ -1,3 +1,3 @@
 {
-  "generatedAt": "2026-10-09T03:35:17.984Z"
+  "generatedAt": "2026-10-13T06:19:09.464Z"
 }

package/dist/cli/api-route-parity.js

@@ -12,6 +12,10 @@ const CONTROL_API_MATCHERS = [
     re("POST", /^\/api\/tasks\/([^/]+)\/(start|pause|message|done)$/.source),
     re("POST", /^\/api\/tasks\/([^/]+)\/preview$/.source),
     re("POST", /^\/api\/tasks\/([^/]+)\/preview\/stop$/.source),
+    // `repoos dev …` (#0747): list/status/get and start/stop/restart.
+    exact("GET", "/api/dev/targets"),
+    re("GET", /^\/api\/dev\/targets\/([^/]+)$/.source),
+    re("POST", /^\/api\/dev\/targets\/([^/]+)\/(start|stop|restart)$/.source),
     exact("GET", "/api/config"),
     exact("PATCH", "/api/config"),
     exact("GET", "/api/remote-validation/status"),

package/dist/cli/help.js

@@ -88,9 +88,9 @@ const GROUPS = [
             },
             {
                 name: "message",
-                usage: 'message <id> "<text>" [--json] [--port N]',
-                desc: "Send a follow-up to the task agent (POST /api/tasks/:id/message)",
-                flags: "--json · --port",
+                usage: 'message <id> "<text>" [--now] [--json] [--port N]',
+                desc: "Send a follow-up to the task agent; queues while busy, --now interrupts the turn and delivers immediately (POST /api/tasks/:id/message)",
+                flags: "--now · --json · --port",
             },
             {
                 name: "review",
@@ -116,6 +116,12 @@ const GROUPS = [
                 desc: "Start or stop the task preview (POST /api/tasks/:id/preview)",
                 flags: "--stop · --json · --port",
             },
+            {
+                name: "dev",
+                usage: "dev [list] · dev <name> start|stop|restart|status|logs [--json] [--port N]",
+                desc: "Start, stop and inspect a declared dev target (GET/POST /api/dev/targets)",
+                flags: "--json · --port",
+            },
             {
                 name: "config",
                 usage: "config get|set <key> [value] [--json] [--port N]",

package/dist/cli/index.js

@@ -21,7 +21,7 @@ import { cmdDoctor } from "../commands/doctor.js";
 import { cmdCertify } from "../commands/certify.js";
 import { cmdSupport } from "../commands/support.js";
 import { cmdService } from "../commands/service.js";
-import { cmdAgentsRunning, cmdConfig, cmdDone, cmdMessage, cmdOverride, cmdPause, cmdPreview, cmdReview, cmdRunners, cmdStart, cmdStats, cmdDecisions, } from "../commands/control-api.js";
+import { cmdAgentsRunning, cmdConfig, cmdDone, cmdMessage, cmdOverride, cmdPause, cmdPreview, cmdDev, cmdReview, cmdRunners, cmdStart, cmdStats, cmdDecisions, } from "../commands/control-api.js";
 import { cmdWatch } from "../commands/watch.js";
 import { cmdDriver } from "../commands/driver.js";
 import { checkBuild } from "../core/build.js";
@@ -242,6 +242,12 @@ function main() {
                     process.exitCode = code;
             });
             break;
+        case "dev":
+            void cmdDev(rest).then((code) => {
+                if (code !== 0)
+                    process.exitCode = code;
+            });
+            break;
         case "config":
             void cmdConfig(rest).then((code) => {
                 if (code !== 0)

package/dist/commands/control-api.d.ts

@@ -5,6 +5,7 @@ export declare function cmdReview(args: string[]): Promise<number>;
 export declare function cmdDone(args: string[]): Promise<number>;
 export declare function cmdOverride(args: string[]): Promise<number>;
 export declare function cmdPreview(args: string[]): Promise<number>;
+export declare function cmdDev(args: string[]): Promise<number>;
 export declare function cmdConfig(args: string[]): Promise<number>;
 export declare function cmdRunners(args: string[]): Promise<number>;
 export declare function cmdAgentsRunning(args: string[]): Promise<number>;

package/dist/commands/control-api.js

@@ -6,7 +6,7 @@ import { pollUntil, RepoOsApi, RepoOsApiError, resolveControlPlaneBase, } from "
 import { effectiveEngineerFromApi } from "../cli/effective-from-api.js";
 import { HANDOFF_DEADLINE_MS } from "../server/handoff.js";
 function parseCommonFlags(args) {
-    const opts = { json: false, wait: false };
+    const opts = { json: false, wait: false, now: false };
     const rest = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
@@ -14,6 +14,8 @@ function parseCommonFlags(args) {
             opts.json = true;
         else if (a === "--wait")
             opts.wait = true;
+        else if (a === "--now")
+            opts.now = true;
         else if (a === "--port") {
             const p = args[++i];
             const n = Number(p);
@@ -133,17 +135,31 @@ export async function cmdMessage(args) {
     const id = rest[0];
     const text = rest.slice(1).join(" ").trim();
     if (!id || !text) {
-        printErr('Usage: repoos message <id> "<text>" [--json] [--port N]');
+        printErr('Usage: repoos message <id> "<text>" [--now] [--json] [--port N]');
         return 1;
     }
     const api = new RepoOsApi({ port: opts.port });
     try {
         await ensureServer(api);
-        const data = await api.requestOk("POST", `/api/tasks/${id}/message`, { text });
+        const data = await api.requestOk("POST", `/api/tasks/${id}/message`, {
+            text,
+            ...(opts.now ? { now: true } : {}),
+        });
         if (opts.json)
             printJson(data);
-        else
+        else if (data?.queued) {
+            const why = data.now
+                ? (data.reason ?? "agent still busy after the interrupt")
+                : "agent busy — delivers when the turn ends";
+            console.log(c.green("  ✓ ") + c.dim(`message queued to #${id} (${why})`));
+        }
+        else if (data?.deliveredNow) {
+            const how = data.interrupted ? " (interrupted the running turn)" : " (agent was idle)";
+            console.log(c.green("  ✓ ") + c.dim(`message delivered now to #${id}${how}`));
+        }
+        else {
             console.log(c.green("  ✓ ") + c.dim(`message sent to #${id}`));
+        }
         return 0;
     }
     catch (e) {
@@ -381,6 +397,100 @@ export async function cmdPreview(args) {
         return 1;
     }
 }
+export async function cmdDev(args) {
+    const { rest, opts, error } = parseCommonFlags(args);
+    if (error) {
+        printErr(error);
+        return 1;
+    }
+    // `repoos dev list` · `repoos dev <name> start|stop|restart` · `repoos dev <name>`
+    // The command run is ALWAYS the one declared in repoos.toml, resolved by name.
+    const sub = rest[0];
+    if (!sub || sub === "list" || sub === "status") {
+        const api = new RepoOsApi({ port: opts.port });
+        try {
+            await ensureServer(api);
+            const data = (await api.requestOk("GET", "/api/dev/targets", undefined));
+            if (opts.json) {
+                printJson(data);
+                return 0;
+            }
+            if (data.errors?.length) {
+                for (const e of data.errors)
+                    console.log(c.yellow("  ! ") + c.dim(e));
+            }
+            const targets = data.targets ?? [];
+            if (!targets.length) {
+                console.log(c.dim("  no dev targets declared in repoos.toml ([[dev.targets]])"));
+                return 0;
+            }
+            for (const t of targets) {
+                const dot = t.status === "running"
+                    ? c.green("●")
+                    : t.status === "failed"
+                        ? c.red("●")
+                        : t.status === "starting"
+                            ? c.yellow("●")
+                            : c.dim("○");
+                const target = t.url ?? t.artifactPath ?? "";
+                console.log(`  ${dot} ${t.name} ${c.dim(`[${t.kind}] ${t.status}`)}${target ? c.dim(` ${target}`) : ""}`);
+                if (t.error)
+                    console.log(c.red(`      ${t.error}`));
+            }
+            return 0;
+        }
+        catch (e) {
+            printErr(e.message);
+            return 1;
+        }
+    }
+    const name = sub;
+    const action = rest[1] ?? "status";
+    const valid = ["start", "stop", "restart", "status", "logs"];
+    if (!valid.includes(action)) {
+        printErr("Usage: repoos dev [list] · repoos dev <name> start|stop|restart|status|logs [--json] [--port N]");
+        return 1;
+    }
+    const api = new RepoOsApi({ port: opts.port });
+    try {
+        await ensureServer(api);
+        const base = `/api/dev/targets/${encodeURIComponent(name)}`;
+        if (action === "start" || action === "stop" || action === "restart") {
+            const data = (await api.requestOk("POST", `${base}/${action}`, {}));
+            if (opts.json) {
+                printJson(data);
+                return 0;
+            }
+            if (data.target?.error) {
+                printErr(`dev target "${name}" ${data.target.status}: ${data.target.error}`);
+                return 1;
+            }
+            console.log(c.green("  ✓ ") +
+                c.dim(`dev target "${name}" ${data.target?.status ?? action}${data.target?.url ? ` ${data.target.url}` : ""}`));
+            return 0;
+        }
+        if (action === "status" || action === "logs") {
+            const data = (await api.requestOk("GET", base, undefined));
+            if (opts.json) {
+                printJson(data);
+                return 0;
+            }
+            console.log(c.dim(`  ${name}: ${data.target?.status ?? "unknown"}`));
+            if (data.target?.error)
+                console.log(c.red(`  ${data.target.error}`));
+            if (action === "logs") {
+                for (const line of data.target?.log ?? [])
+                    console.log(`  ${line}`);
+            }
+            return 0;
+        }
+        return 0;
+    }
+    catch (e) {
+        printErr(e.message);
+        return 1;
+    }
+}
 export async function cmdConfig(args) {
     const { rest, opts, error } = parseCommonFlags(args);
     if (error) {

package/dist/commands/init.js

@@ -296,8 +296,13 @@ Problem / Desired UX / Acceptance criteria / Notes for AI is refused unless
 \`--force\` is passed.
 
 For tabbed views (e.g. Agents), prefer \`?tab=<id>\` routes
-(\`/agents?tab=detected\`) over click steps to reach the right tab, and always
-set \`highlight\` to the changed elements. A declared \`highlight\` or \`selector\`
+(\`/agents?tab=detected\`) over click steps to reach the right tab; a task drawer
+is reached the same way (\`/work?task=<id>&tab=changes\`), and always
+set \`highlight\` to the changed elements. Reach a populated state with a
+\`route\` or a named \`state\` fixture, never with \`steps\` that click a
+placeholder selector (\`data-task-id "9999"\` and the like) — such a step times
+out and the capture lands on a loading state instead of the content, which is
+reported as a failed step, not a match. A declared \`highlight\` or \`selector\`
 that matches nothing at capture time records a visible warning — capture still
 succeeds. Declared shots default to the whole visible window (\`fullPage:
 false\`) with changed elements outlined via \`highlight\`; \`selector\` (element

package/dist/commands/ui-contrast-audit.js

@@ -676,10 +676,63 @@ function makeAuditFixture() {
                 mime: "image/png",
             });
         }
+        // #0753: handoff verification evidence so the Changes tab renders the
+        // per-shot check/cross verdict icon and the "Handoff checked …" status line
+        // — both are real text/colour the audit must gate. One matching shot and
+        // one checking shot with a failed step, plus a console/overflow issue so
+        // the popover's content is present too.
+        const shots = localShotStore(config, "0001");
+        const first = shots.list()[0];
+        const second = shots.list()[1];
+        const savedUrls = [];
+        if (first)
+            savedUrls.push(first.url);
+        if (second)
+            savedUrls.push(second.url);
+        const cacheDir = join(root, config.cacheDir || ".repoos", "ui-verification");
+        mkdirSync(cacheDir, { recursive: true });
+        writeFileSync(join(cacheDir, "0001.json"), JSON.stringify({
+            at: new Date().toISOString(),
+            issues: [
+                { kind: "console", message: "TypeError: fixture is undefined" },
+                { kind: "overflow", message: "content wider than viewport", viewportWidth: 1280 },
+            ],
+            blankShots: [],
+            captures: savedUrls.length,
+            sourceIdentity: "fixture0001",
+            evidenceDir: "work/.attachments/0001/shots",
+            captureDetails: [
+                {
+                    target: "default",
+                    route: "/",
+                    label: "Dashboard",
+                    url: "http://127.0.0.1:0/",
+                    finalRoute: "/",
+                    routeMatched: true,
+                    assertions: [],
+                    assertionsPassed: 0,
+                    assertionsChecked: 0,
+                    ...(savedUrls[0] ? { shot: { name: "a", path: "", url: savedUrls[0] } } : {}),
+                },
+                {
+                    target: "default",
+                    route: "/",
+                    label: "Auto shot",
+                    url: "http://127.0.0.1:0/",
+                    finalRoute: "/",
+                    routeMatched: true,
+                    targetWarnings: ['click [data-test-id="fullscreen"]: Timeout 5000ms exceeded'],
+                    assertions: [],
+                    assertionsPassed: 0,
+                    assertionsChecked: 0,
+                    ...(savedUrls[1] ? { shot: { name: "b", path: "", url: savedUrls[1] } } : {}),
+                },
+            ],
+        }));
     }
     catch {
-        // The shot store is disk-only and cannot realistically fail here; if it
-        // does, the Changes tab simply has no shots to audit.
+        // The shot/verification store is disk-only and cannot realistically fail
+        // here; if it does, the Changes tab simply has less to audit.
     }
     return root;
 }

package/dist/core/config.d.ts

@@ -1,4 +1,5 @@
 import type { Agent, BuiltInAgentConfig, DistributionConfig, PreviewConfig, RepoOSConfig, AreaConfig } from "./types.js";
+export { parseDevTargets } from "./dev-targets.js";
 /** Default display labels for board columns, keyed by canonical status ID. */
 export declare const DEFAULT_COLUMN_LABELS: Record<string, string>;
 /** Coding agents an Agent can run under. */

package/dist/core/config.js

@@ -8,9 +8,14 @@ import { cpus } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { STATUSES } from "./types.js";
 import { parseCheckPlanConfig } from "./check-plan.js";
+import { parseDevTargets } from "./dev-targets.js";
 import { parseTailscaleHosts } from "./remote-hosts.js";
 import { DEFAULT_STORAGE_PROVIDER_ID } from "./storage/registry.js";
 import { stripTomlComment, unquoteTomlString } from "./toml-line.js";
+// `parseDevTargets` (#0747) lives in the node-free `core/dev-targets.ts` so the
+// browser bundle can validate a target through the SAME function the server
+// uses (#0749). Re-exported for the existing core/CLI importers.
+export { parseDevTargets } from "./dev-targets.js";
 /** Default display labels for board columns, keyed by canonical status ID. */
 export const DEFAULT_COLUMN_LABELS = {
     draft: "Draft",
@@ -1106,8 +1111,16 @@ export function loadConfig(rootArg, options = {}) {
                 enabled: typeof devInspectorEnabled === "boolean" ? devInspectorEnabled : true,
                 editorCommand: typeof devInspectorEditor === "string" ? devInspectorEditor.trim() : "",
             };
-            cfg.dev = { inspector };
-        }
+            cfg.dev = { ...cfg.dev, inspector };
+        }
+        // [[dev.targets]] (#0747) — the user-declared runnable dev targets. Bad
+        // rows are recorded as validation errors on the config, not silently
+        // dropped: the Dev page and CLI surface them so a typo is visible.
+        const devTargets = parseDevTargets(parsed);
+        if (devTargets.targets.length)
+            cfg.dev = { ...cfg.dev, targets: devTargets.targets };
+        if (devTargets.errors.length)
+            cfg.devTargetErrors = devTargets.errors;
         if (typeof get("ntfyEnabled") === "boolean")
             cfg.ntfyEnabled = get("ntfyEnabled");
         if (typeof get("ntfyTopic") === "string")
@@ -2431,6 +2444,21 @@ export function getConfigSchema() {
             default: "",
             description: "Optional editor launcher, e.g. `zed {file}:{line}`. Placeholders `{file}` and `{line}`; omit `{line}` to open without a line number.",
         },
+        {
+            // The Settings control is a dedicated hand-rendered card on Advanced
+            // (#0749), never an auto-rendered General row — like `areas`, this schema
+            // entry exists so the search overlay and the "does this key have a UI
+            // row?" resolver can find it.
+            key: "dev.targets",
+            label: "Dev targets",
+            type: "array",
+            tier: "live",
+            restartRequired: false,
+            default: [],
+            description: "The things you run yourself while developing — a local HMR web server, a debug build, a native app process — " +
+                "as opposed to task previews, which RepoOS manages for a task's worktree. Only commands " +
+                "declared here can be started; edit them under Advanced → Dev targets.",
+        },
         // [board.columns] — display-only label overrides (#0396).
         ...STATUSES.map((status) => ({
             key: `board.columns.${status}`,
@@ -2516,6 +2544,16 @@ export const SUPPORTED_TOML_KEYS = [
     "preview.services.cwd",
     "preview.services.readyPath",
     "preview.services.readyTimeoutMs",
+    // Dev targets (#0747) — the user-runnable things the Dev page controls.
+    // Declared as a repeatable `[[dev.targets]]` table; each row is one target.
+    "dev.targets.name",
+    "dev.targets.kind",
+    "dev.targets.command",
+    "dev.targets.url",
+    "dev.targets.artifactPath",
+    "dev.targets.label",
+    "dev.targets.healthCheck.url",
+    "dev.targets.healthCheck.file",
     // Preview-only overrides (#0464): a `[preview.<base path>]` table applied
     // only by the preview/UI-test preview runtime. auth.enabled is the headline
     // case; any supported base key can be overridden the same way.

package/dist/core/dev-targets.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `[[dev.targets]]` parsing (#0747, extracted node-free in #0749).
+ *
+ * The user-declared runnable dev targets are parsed here rather than in
+ * `core/config.ts` so the SAME validator runs in the browser bundle: the
+ * Settings control composes a row and validates it through `parseDevTargets`,
+ * exactly as the server re-validates the submitted list. `core/config.ts` has
+ * node imports (`node:fs`, `node:os`, `node:path`) and cannot be pulled into the
+ * Vite browser build, so this pure function lives on its own.
+ *
+ * Unlike `[preview]`, which resolves cleanly to "nothing" and drops bad rows, a
+ * dev target is something the user asked the server to run, so an unusable row
+ * is a loud validation error rather than a silent drop: a target with a missing
+ * name/command/kind or a conflicting field is reported with a clear message.
+ */
+import type { DevTargetConfig } from "./types.js";
+/**
+ * Parse the `[[dev.targets]]` array of tables — the user-declared runnable dev
+ * targets. Returns `{ targets, errors }`; `loadConfig` records the errors on
+ * the config so the API/UI can surface them.
+ */
+export declare function parseDevTargets(parsed: Record<string, unknown>): {
+    targets: DevTargetConfig[];
+    errors: string[];
+};

package/dist/core/dev-targets.js

@@ -0,0 +1,155 @@
+/**
+ * Parse the flat TOML parser's leftover inline-table string for `healthCheck`
+ * (`'{ url = "..." }'` — `parseFlatToml` has no inline-table support, so the
+ * whole table stays a string). Returns the url/file fields, or null when the
+ * string is not a `{ … }` table at all, so the caller can report the right
+ * error. Quoted string values only, which is all a URL or a file path needs.
+ */
+function parseInlineHealthCheck(raw) {
+    const s = raw.trim();
+    if (!s.startsWith("{") || !s.endsWith("}"))
+        return null;
+    const out = {};
+    for (const m of s.slice(1, -1).matchAll(/([A-Za-z0-9_]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) {
+        const value = (m[2] ?? m[3] ?? "").trim();
+        if (!value)
+            continue;
+        if (m[1] === "url")
+            out.url = value;
+        else if (m[1] === "file")
+            out.file = value;
+    }
+    return out;
+}
+/**
+ * Parse the `[[dev.targets]]` array of tables — the user-declared runnable dev
+ * targets. Returns `{ targets, errors }`; `loadConfig` records the errors on
+ * the config so the API/UI can surface them.
+ */
+export function parseDevTargets(parsed) {
+    const raw = parsed["dev.targets"];
+    const targets = [];
+    const errors = [];
+    if (raw === undefined)
+        return { targets, errors };
+    if (!Array.isArray(raw)) {
+        errors.push("[dev.targets] must be an array of tables");
+        return { targets, errors };
+    }
+    const seen = new Set();
+    for (const entry of raw) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            errors.push("[dev.targets] ignoring a non-table row");
+            continue;
+        }
+        const r = entry;
+        const name = typeof r.name === "string" ? r.name.trim() : "";
+        if (!name) {
+            errors.push("[dev.targets] a target is missing a name");
+            continue;
+        }
+        if (seen.has(name)) {
+            errors.push(`[dev.targets] duplicate target name "${name}"`);
+            continue;
+        }
+        const kindRaw = typeof r.kind === "string" ? r.kind.trim() : "";
+        if (kindRaw !== "server" && kindRaw !== "artifact" && kindRaw !== "process") {
+            errors.push(`[dev.targets] ${name}: kind must be "server", "artifact" or "process"${kindRaw ? ` (got "${kindRaw}")` : ""}`);
+            continue;
+        }
+        const command = typeof r.command === "string" ? r.command.trim() : "";
+        if (!command) {
+            errors.push(`[dev.targets] ${name}: a command is required`);
+            continue;
+        }
+        const target = { name, kind: kindRaw, command };
+        const url = typeof r.url === "string" ? r.url.trim() : "";
+        const artifactPath = typeof r.artifactPath === "string" ? r.artifactPath.trim() : "";
+        if (kindRaw === "server" && !url) {
+            // A long-lived target with no URL is a `process`, not a `server` — point
+            // the user at the right kind rather than leaving them stuck.
+            errors.push(`[dev.targets] ${name}: a "server" target needs a url (use kind = "process" for a long-lived target with no URL)`);
+            continue;
+        }
+        if (kindRaw === "artifact" && !artifactPath) {
+            errors.push(`[dev.targets] ${name}: an "artifact" target needs an artifactPath`);
+            continue;
+        }
+        if (kindRaw === "server" && artifactPath) {
+            errors.push(`[dev.targets] ${name}: a "server" target cannot have an artifactPath`);
+            continue;
+        }
+        if (kindRaw === "artifact" && url) {
+            errors.push(`[dev.targets] ${name}: an "artifact" target cannot have a url`);
+            continue;
+        }
+        // A process has neither a URL nor a build artifact — it is healthy while it
+        // is alive, which is its health check. Reject the conflicting fields so a
+        // typo can never silently change what the target means.
+        if (kindRaw === "process" && url) {
+            errors.push(`[dev.targets] ${name}: a "process" target cannot have a url`);
+            continue;
+        }
+        if (kindRaw === "process" && artifactPath) {
+            errors.push(`[dev.targets] ${name}: a "process" target cannot have an artifactPath`);
+            continue;
+        }
+        if (url)
+            target.url = url;
+        if (artifactPath)
+            target.artifactPath = artifactPath;
+        const label = typeof r.label === "string" ? r.label.trim() : "";
+        if (label)
+            target.label = label;
+        // healthCheck arrives in one of three shapes, all accepted here so the
+        // documented `healthCheck = { url = "..." }` actually works:
+        //   - an object, from a real TOML parser (or a test passing rows directly);
+        //   - the raw inline-table string the flat line parser leaves behind
+        //     (`'{ url = "..." }'`, since it has no inline-table support);
+        //   - dotted keys `healthCheck.url` / `healthCheck.file`, which the flat
+        //     parser keeps as literal keys on the row.
+        const hcRaw = r.healthCheck;
+        let hcUrl = typeof r["healthCheck.url"] === "string" ? r["healthCheck.url"].trim() : "";
+        let hcFile = typeof r["healthCheck.file"] === "string" ? r["healthCheck.file"].trim() : "";
+        const hasInlineKeys = r["healthCheck.url"] !== undefined || r["healthCheck.file"] !== undefined;
+        if (hcRaw !== undefined) {
+            if (typeof hcRaw === "string") {
+                const parsedHc = parseInlineHealthCheck(hcRaw);
+                if (!parsedHc) {
+                    errors.push(`[dev.targets] ${name}: healthCheck must be a table with url or file`);
+                    continue;
+                }
+                hcUrl = hcUrl || parsedHc.url || "";
+                hcFile = hcFile || parsedHc.file || "";
+            }
+            else if (typeof hcRaw === "object" && hcRaw !== null && !Array.isArray(hcRaw)) {
+                const hc = hcRaw;
+                hcUrl = hcUrl || (typeof hc.url === "string" ? hc.url.trim() : "");
+                hcFile = hcFile || (typeof hc.file === "string" ? hc.file.trim() : "");
+            }
+            else {
+                errors.push(`[dev.targets] ${name}: healthCheck must be a table with url or file`);
+                continue;
+            }
+        }
+        if (hcUrl || hcFile) {
+            target.healthCheck = {
+                ...(hcUrl ? { url: hcUrl } : {}),
+                ...(hcFile ? { file: hcFile } : {}),
+            };
+        }
+        else if (hcRaw !== undefined || hasInlineKeys) {
+            errors.push(`[dev.targets] ${name}: healthCheck needs a url or a file`);
+            continue;
+        }
+        // A process is healthy while its process is alive; a readiness check would
+        // only muddy that. Reject one rather than silently ignore it.
+        if (kindRaw === "process" && target.healthCheck) {
+            errors.push(`[dev.targets] ${name}: a "process" target cannot have a healthCheck (it is running while its process is alive)`);
+            continue;
+        }
+        seen.add(name);
+        targets.push(target);
+    }
+    return { targets, errors };
+}

package/dist/core/git.d.ts

@@ -407,6 +407,12 @@ export declare function gitInit(root: string): boolean;
  * where 0023's surgical `commitNewFile` applies. Fail-soft: null on failure.
  */
 export declare function gitCommitAll(root: string, message: string): string | null;
+/**
+ * The short HEAD sha of `root`, or null when git is unavailable or the path is
+ * not a repository (#0755). Used to tie handoff UI evidence to the exact tree
+ * it captured, so a later commit can be flagged as a stale capture.
+ */
+export declare function shortHeadOf(root: string): string | null;
 export interface CommitNewFileResult {
     ok: boolean;
     /** Short commit hash (when committed). */
@@ -638,6 +644,18 @@ export interface UncommittedWorkFilesOptions {
  * the default answer for handoff and pre-merge guards.
  */
 export declare function uncommittedWorkFiles(root: string, filter?: WorkFileFilter, opts?: UncommittedWorkFilesOptions): Promise<string[]>;
+/**
+ * Whether a path that conflicted between two sides is one the merge is allowed
+ * to resolve on its own: it matches an `autoResolve` entry (generated output,
+ * the closing task's own file) or an `autoResolveOurs` entry (unrelated task
+ * files, where main's copy wins). A conflicted path matching neither is a REAL
+ * conflict. This is the single definition of "a real conflict" shared by the
+ * real merge and `mergeBranch`'s dry-run pre-flight, so the two can never drift.
+ */
+export declare function isResolvableConflict(path: string, opts: {
+    autoResolve?: string[];
+    autoResolveOurs?: string[];
+}): boolean;
 /**
  * Merge `branch` into the CURRENT checkout — the main worktree, never the
  * task's worktree. Default merge semantics: fast-forward when main is an

package/dist/core/git.js

@@ -1116,6 +1116,15 @@ export function gitCommitAll(root, message) {
     notifyGitMutation(root, "commit");
     return git(root, ["rev-parse", "--short", "HEAD"]);
 }
+/**
+ * The short HEAD sha of `root`, or null when git is unavailable or the path is
+ * not a repository (#0755). Used to tie handoff UI evidence to the exact tree
+ * it captured, so a later commit can be flagged as a stale capture.
+ */
+export function shortHeadOf(root) {
+    const sha = git(root, ["rev-parse", "--short", "HEAD"]);
+    return sha ? sha.trim() || null : null;
+}
 /**
  * Surgically commit a single new file with the user's own git identity.
  *
@@ -1518,7 +1527,7 @@ function blockingFiles(stderr) {
  * conflict. This is the single definition of "a real conflict" shared by the
  * real merge and `mergeBranch`'s dry-run pre-flight, so the two can never drift.
  */
-function isResolvableConflict(path, opts) {
+export function isResolvableConflict(path, opts) {
     const matches = (rule, p) => p === rule || p.startsWith(rule.endsWith("/") ? rule : rule + "/");
     return [...(opts.autoResolve ?? []), ...(opts.autoResolveOurs ?? [])].some((r) => matches(r, path));
 }

package/dist/core/models.js

@@ -293,10 +293,16 @@ const opencodeAdapter = {
             };
         const args = opts.refresh ? ["models", "--refresh"] : ["models"];
         const timeoutMs = opts.timeoutMs ?? MODELS_TIMEOUT_MS;
-        const out = await spawnModels(bin, args, {
+        let out = await spawnModels(bin, args, {
             timeoutMs,
             cwd: opts.cwd,
         });
+        // Some opencode builds (v2.0.11 among them) reject `--refresh` with exit 1.
+        // Retry the plain probe: the caller has already bypassed RepoOS's own cache,
+        // so this is still a fresh list rather than the cached one.
+        if (opts.refresh && out.code !== 0 && /Unrecognized flag: --refresh/.test(out.stderr)) {
+            out = await spawnModels(bin, ["models"], { timeoutMs, cwd: opts.cwd });
+        }
         const error = probeError(bin, out, timeoutMs);
         return {
             supported: true,