@repo-os/repoos 0.5.64 → 0.5.65

package/dist/.build-info.json

@@ -1,5 +1,5 @@
 {
-  "hash": "fe42b7d3c5e92f40a7421aa079b19143152aaa5475d60de61c7098723741384f",
-  "version": "0.5.64",
+  "hash": "5139d67402c747817a7237d45bbdf3dc259350732a389c4dc4f1037533e74fc0",
+  "version": "0.5.65",
   "devUi": false
 }

package/dist/.build-stamp.json

@@ -1,3 +1,3 @@
 {
-  "generatedAt": "2026-10-04T11:13:13.008Z"
+  "generatedAt": "2026-10-05T04:53:51.934Z"
 }

package/dist/cli/help.js

@@ -86,6 +86,17 @@ const GROUPS = [
             },
         ],
     },
+    {
+        name: "Code",
+        commands: [
+            {
+                name: "outline",
+                usage: "outline <file> [--json]",
+                desc: "Print a file's symbols and line ranges (read ranges, not whole files)",
+                flags: "--json",
+            },
+        ],
+    },
     {
         name: "Health",
         commands: [
@@ -109,9 +120,9 @@ const GROUPS = [
             },
             {
                 name: "certify",
-                usage: "certify <cli> [--yes] [--json] [--binary <path>]",
+                usage: "certify <cli> [--yes] [--json] [--force] [--binary <path>]",
                 desc: "Run the adapter contract suite and record certification evidence",
-                flags: "--yes · --json · --binary <path>",
+                flags: "--yes · --json · --force · --binary <path>",
             },
             {
                 name: "support",
@@ -169,6 +180,7 @@ const EXAMPLES = [
     { cmd: 'repoos note 0012 "Handle the reviewer\'s suggestions before the next review"' },
     { cmd: 'repoos update 0012 --title "New title" --area web,core' },
     { cmd: "repoos list ready" },
+    { cmd: "repoos outline src/server/agents.ts", comment: "then read only the range you need" },
     { cmd: "repoos doctor", comment: "passing checks are hidden; --verbose shows all" },
     { cmd: "repoos shot", comment: "screenshot the task preview for the current worktree" },
     { cmd: "repoos shot /repo/commits/abc123", comment: "capture one route" },

package/dist/cli/index.js

@@ -7,6 +7,7 @@ import { cmdInit } from "../commands/init.js";
 import { cmdList, cmdShow, cmdMv, cmdUpdate, cmdNew, cmdIndex, cmdNote, } from "../commands/tasks.js";
 import { cmdNewDoc } from "../commands/docs.js";
 import { cmdGc } from "../commands/gc.js";
+import { cmdOutline } from "../commands/outline.js";
 import { cmdCheck } from "../commands/check.js";
 import { cmdShot } from "../commands/shot.js";
 import { cmdServe, serveProcessTitle, setServeProcessTitle } from "../commands/serve.js";
@@ -89,6 +90,9 @@ function main() {
         "-h",
         "upgrade",
         "uninstall",
+        // Read-only inspection of one file: the build-staleness hash is pure
+        // overhead here, and `outline` is meant to stay well under 200ms.
+        "outline",
     ]);
     if (!skipCheck.has(cmd)) {
         const result = checkBuild();
@@ -165,6 +169,9 @@ function main() {
         case "gc":
             cmdGc(rest);
             break;
+        case "outline":
+            cmdOutline(rest);
+            break;
         case "serve":
         case "server":
             void cmdServe(rest);

package/dist/commands/certify.d.ts

@@ -2,6 +2,8 @@ export interface CertifyCliArgs {
     cli: string | null;
     yes: boolean;
     json: boolean;
+    /** `--force`: run the probe even when this version is already certified. */
+    force: boolean;
     missingCli: boolean;
     /** Explicit binary path — skips PATH resolution and probes this binary directly. */
     binary: string | null;

package/dist/commands/certify.js

@@ -1,5 +1,5 @@
 /**
- * `repoos certify <cli> [--yes] [--json]` — run the adapter contract suite and,
+ * `repoos certify <cli> [--yes] [--json] [--force]` — run the adapter contract suite and,
  * when every seam passes, write the certification evidence back into
  * `src/core/agent-compatibility.json` automatically.
  *
@@ -11,33 +11,40 @@
  * does — src/core/ in a dev checkout, dist/core/ in a built install — and
  * writes back to whichever file it loaded from.
  */
+import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { join } from "node:path";
-import { runAdapterContract } from "../core/agent-contract.js";
+import { resolveProbeModel, runAdapterContract } from "../core/agent-contract.js";
 import { parseAgentVersion } from "../core/agent-compatibility.js";
+import { KNOWN_AGENTS, resolveBinary } from "../core/detect.js";
 import { c } from "../cli/colors.js";
 export function parseCertifyArgs(argv) {
     const yes = argv.includes("--yes");
     const json = argv.includes("--json");
+    const force = argv.includes("--force");
     const binaryIdx = argv.indexOf("--binary");
     const binary = binaryIdx !== -1 ? (argv[binaryIdx + 1] ?? null) : null;
     const modelIdx = argv.indexOf("--model");
     const model = modelIdx !== -1 ? (argv[modelIdx + 1] ?? null) : null;
     const positional = argv.filter((a, i) => !a.startsWith("--") && argv[i - 1] !== "--binary" && argv[i - 1] !== "--model");
     const cli = positional[0] ?? null;
-    return { cli, yes, json, missingCli: !cli, binary, model };
+    return { cli, yes, json, force, missingCli: !cli, binary, model };
 }
 /** Locate the live manifest file on disk (src or dist). */
 function findManifestPath() {
     const manifestUrl = new URL("../core/agent-compatibility.json", import.meta.url);
     const candidates = [];
+    // The committed manifest is src/'s copy; dist/ is gitignored build output, so
+    // a run from a built checkout must still write src/ or the evidence is lost.
+    candidates.push(join(process.cwd(), "src/core/agent-compatibility.json"));
     if (manifestUrl.protocol === "file:") {
         candidates.push(fileURLToPath(manifestUrl));
     }
-    candidates.push(join(process.cwd(), "src/core/agent-compatibility.json"), join(process.cwd(), "dist/core/agent-compatibility.json"));
+    candidates.push(join(process.cwd(), "dist/core/agent-compatibility.json"));
     const root = process.env.REPOOS_ROOT;
     if (root) {
+        candidates.unshift(join(root, "src/core/agent-compatibility.json"));
         candidates.push(join(root, "src/core/agent-compatibility.json"), join(root, "dist/core/agent-compatibility.json"));
     }
     for (const p of candidates) {
@@ -57,14 +64,69 @@ function loadManifest(path) {
 function saveManifest(path, manifest) {
     writeFileSync(path, JSON.stringify(manifest, null, 2) + "\n", "utf8");
 }
+/**
+ * The installed version when it is already covered by the manifest (equal to or
+ * older than `newestCertifiedVersion`), else null. Reads only `--version` — no
+ * tokens. Any doubt (missing binary, unparsable version, no entry) returns
+ * null so the probe runs.
+ */
+function alreadyCertified(cli, binaryOverride) {
+    try {
+        const known = KNOWN_AGENTS.find((a) => a.cli === cli)?.binary;
+        const bin = binaryOverride ?? (known ? resolveBinary(known) : null);
+        if (!bin || !existsSync(bin))
+            return null;
+        const out = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 10_000 });
+        const installed = parseAgentVersion(`${out.stdout ?? ""}\n${out.stderr ?? ""}`);
+        const path = findManifestPath();
+        if (!installed || !path)
+            return null;
+        const entry = loadManifest(path).contracts.find((e) => e.cli === cli);
+        const newest = entry?.newestCertifiedVersion ?? null;
+        const newestParsed = newest ? parseAgentVersion(newest) : null;
+        if (!newest || !newestParsed)
+            return null;
+        for (let i = 0; i < 3; i++) {
+            if (installed[i] > newestParsed[i])
+                return null;
+            if (installed[i] < newestParsed[i])
+                break;
+        }
+        return { version: installed.join("."), newest };
+    }
+    catch {
+        return null;
+    }
+}
 export async function cmdCertify(argv) {
-    const { cli, yes, json: asJson, missingCli, binary, model } = parseCertifyArgs(argv);
+    const { cli, yes, json: asJson, force, missingCli, binary, model } = parseCertifyArgs(argv);
     if (missingCli || !cli) {
         console.error(c.red("  repoos certify needs a harness id, e.g. `repoos certify opencode`."));
         console.error(c.dim("    Use --binary <path> to probe a specific binary instead of PATH resolution."));
         process.exitCode = 1;
         return;
     }
+    // Skip by default when the installed version is already certified: the live
+    // probe spends provider tokens, and re-running it on a covered version only
+    // rewrites the date. `--force` re-probes anyway.
+    if (!force) {
+        const covered = alreadyCertified(cli, binary);
+        if (covered) {
+            if (asJson) {
+                console.log(JSON.stringify({ cli, skipped: true, version: covered.version }, null, 2));
+            }
+            else {
+                console.log("");
+                console.log("  " +
+                    c.green("✔ Skipped") +
+                    ` — ${cli} ${covered.version} is already certified` +
+                    c.dim(` (newest certified: ${covered.newest}).`));
+                console.log(c.dim("    Use --force to re-run the live probe anyway."));
+                console.log("");
+            }
+            return;
+        }
+    }
     const WARNING = [
         "",
         c.yellow(c.bold("⚠ Live compatibility probe + manifest write")),
@@ -144,7 +206,8 @@ export async function cmdCertify(argv) {
     const manifest = loadManifest(manifestPath);
     const versionStr = result.detectedVersion ? result.detectedVersion.join(".") : null;
     const now = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
-    const source = `repoos certify ${cli} live probe — ${result.capabilities.length}/${result.capabilities.length} seams passed on ${result.startedAt} against binary ${result.binary}`;
+    const probeModelUsed = resolveProbeModel(cli, "live", model);
+    const source = `repoos certify ${cli} live probe — ${result.capabilities.length}/${result.capabilities.length} seams passed on ${result.startedAt} against binary ${result.binary}${probeModelUsed ? ` on model ${probeModelUsed}` : ""}`;
     let contract = manifest.contracts.find((c) => c.cli === cli);
     if (!contract) {
         // Bootstrap a minimal contract for a harness that has no entry yet.

package/dist/commands/check.d.ts

@@ -1,6 +1,7 @@
 import type { CheckContrastPair, CheckThemeScope, RepoOSConfig } from "../core/types.js";
 import { type CheckPlan, type CheckStep } from "../core/check-plan.js";
 import { type StepRunResult } from "../core/check-runner.js";
+import { type CheckRunPhase } from "../core/check-store.js";
 /**
  * Bare `require(...)` calls guard (#0271 follow-up): this package is
  * `"type": "module"` (ESM) — a bare, un-shadowed `require` is undefined at
@@ -213,9 +214,36 @@ export interface CheckOptions {
     printPlan?: boolean;
     /** Skip the remote runner even when `remoteValidation.enabled` (#0520). */
     localTestsOnly?: boolean;
+    /**
+     * Run each `format` step's fixer before its check (#0651). Off by default,
+     * so the close-out gate still fails an unformatted committed tree; handoff
+     * opts in. `kind = "format"` fixes via the `fmt` script, or a step's `fix`.
+     */
+    fix?: boolean;
+    /** Only run these step names — backs `repoos check --step <name>` (#0651). */
+    steps?: string[];
 }
 /** Parse `repoos check` flags. Unknown flags are ignored, never fatal. */
 export declare function parseCheckArgs(argv?: string[]): CheckOptions;
+/** Hard cap on failing files that get an isolation re-run (#0655). Above it,
+ *  the failure is broad enough that per-file triage says nothing useful. */
+export declare const MAX_ISOLATION_TRIAGE_FILES = 3;
+/** The test file from a `file > suite > test` failed-test name. */
+export declare function failedTestFile(name: string): string;
+/**
+ * Unique, still-present test files from recorded failure names, in order.
+ * A filter naming a deleted file makes vitest exit 1 on "no test files found",
+ * which would be a false failed-first failure — so drop paths that don't exist.
+ */
+export declare function failedTestFiles(names: string[], repoRoot: string): string[];
+/**
+ * Args appended after `--` that scope a project's test script to `files`, or
+ * null when the script can't be scoped that way (#0655). RepoOS's own two-pass
+ * runner gets its dedicated `--failed-first` single-pass mode (so the
+ * latency-sensitive isolated pass is skipped); a plain vitest/jest script
+ * accepts positional file filters.
+ */
+export declare function testFileFilterArgs(testScript: string | undefined, files: string[]): string[] | null;
 /**
  * Repo-relative paths that differ from `ref`, plus anything uncommitted or
  * untracked — the working tree an agent actually hands over, not just what is
@@ -236,6 +264,14 @@ export interface RunPlanOptions {
     changedPaths?: string[];
     /** Git ref the changed paths came from — the Tests step scopes itself to it. */
     changedRef?: string;
+    /** Run each `format` step's fixer before its check (#0651). */
+    fix?: boolean;
+    /** Only run these step names (`repoos check --step`). Empty means all. */
+    stepNames?: string[];
+    /** Failing test names from the previous run, for failed-first ordering (#0655). */
+    previousFailedTests?: string[];
+    /** Isolation re-runs per failing file for the flake-triage label (#0655). */
+    isolationRuns?: number;
     onStart?: (step: CheckStep) => void;
     onResult?: (result: StepRunResult) => void;
 }
@@ -251,3 +287,17 @@ export interface RunPlanOptions {
  */
 export declare function runCheckPlan(plan: CheckPlan, opts: RunPlanOptions): Promise<StepRunResult[]>;
 export declare function cmdCheck(argv?: string[]): Promise<void>;
+/**
+ * Failing test names from this task's most recent run (#0655), or none. Only
+ * when that most recent run actually failed — once a run is green, the next
+ * `repoos check` starts from a clean slate. Interactive/CLI and pre-review
+ * only: close-out and release always run the full suite. Fail-soft.
+ */
+export declare function previousFailedTestsForRun(opts: {
+    root: string;
+    cacheDir: string;
+    /** Absolute worktree path the new run will execute in, when known. */
+    worktree?: string;
+    taskId: string | null;
+    phase: CheckRunPhase;
+}): string[];