@mrace07/kairo 0.1.0

package/dist/application/self-evaluation.js

@@ -0,0 +1,394 @@
+import { spawn } from "node:child_process";
+import { cp, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { SqliteSessionStore } from "../infrastructure/persistence/sqlite-session-store.js";
+import { createProvider } from "../infrastructure/providers/provider-registry.js";
+import { RepositoryProfiler } from "../infrastructure/repository/repository-profiler.js";
+import { WorkspaceTools, definitions } from "../infrastructure/tools/workspace-tools.js";
+import { CodingAgent } from "./coding-agent.js";
+import { taskMetrics } from "./task-metrics.js";
+import { runEvaluatedAgent } from "./evaluated-agent.js";
+const replacement = async (workspace, path, before, after) => {
+    const target = join(workspace, path);
+    const source = await readFile(target, "utf8");
+    if (!source.includes(before))
+        throw new Error(`Self-eval seed no longer matches ${path}.`);
+    await writeFile(target, source.replace(before, after), "utf8");
+};
+/** Seven real Kairo safeguards, deliberately removed from isolated source copies. */
+export const selfEvaluationScenarios = [
+    {
+        id: "verification-check-script",
+        prompt: "A JavaScript project with only a `check` package script is not offered a typecheck verification command. Fix verification discovery so the `check` script is recognized as typecheck, preserve package-manager command formats, add or update a focused test, and run relevant verification.",
+        seed: (workspace) => replacement(workspace, "src/application/verification-planner.ts", '["typecheck", ["typecheck", "type-check", "check"]]', '["typecheck", ["typecheck", "type-check"]]'),
+        async verify(workspace) {
+            const module = await import(pathToFileURL(join(workspace, "dist/application/verification-planner.js")).href);
+            const candidates = new module.VerificationPlanner().candidates({
+                packageManager: "pnpm",
+                scripts: { check: "tsc --noEmit" },
+            });
+            if (candidates[0]?.label !== "typecheck" || candidates[0]?.command !== "pnpm check")
+                throw new Error("A pnpm check script was not exposed as typecheck.");
+        },
+    },
+    {
+        id: "focused-verification-selection",
+        prompt: "Kairo no longer recommends the focused typecheck for a changed TypeScript source file. Restore changed-file-aware verification selection, add or update a focused test, and run relevant verification.",
+        seed: (workspace) => replacement(workspace, "src/application/verification-planner.ts", 'if (isSource && byLabel("typecheck"))', "if (false)"),
+        async verify(workspace) {
+            const module = await import(pathToFileURL(join(workspace, "dist/application/verification-planner.js")).href);
+            const selection = new module.VerificationPlanner().select({
+                sourceRoots: ["src"],
+                testRoots: ["test"],
+                configFiles: [],
+                verificationCandidates: [
+                    { label: "test", command: "pnpm test" },
+                    { label: "typecheck", command: "pnpm check" },
+                ],
+            }, ["src/login.ts"]);
+            if (selection?.command !== "pnpm check" || selection.scope !== "broad")
+                throw new Error("A changed source file did not select focused typechecking.");
+        },
+    },
+    {
+        id: "bun-lockfile-discovery",
+        prompt: "Repository profiling fails to recognize projects using Bun's current bun.lock file. Restore support without regressing bun.lockb, add or update a focused test, and run relevant verification.",
+        seed: (workspace) => replacement(workspace, "src/infrastructure/repository/repository-profiler.ts", 'paths.has("bun.lockb") || paths.has("bun.lock")', 'paths.has("bun.lockb")'),
+        async verify(workspace) {
+            const fixture = await mkdtemp(join(tmpdir(), "kairo-bun-grader-"));
+            try {
+                await Promise.all([
+                    writeFile(join(fixture, "package.json"), '{"name":"bun-fixture"}\n'),
+                    writeFile(join(fixture, "bun.lock"), "# bun lockfile\n"),
+                ]);
+                const module = await import(pathToFileURL(join(workspace, "dist/infrastructure/repository/repository-profiler.js"))
+                    .href);
+                if ((await new module.RepositoryProfiler().profile(fixture)).packageManager !== "bun")
+                    throw new Error("A project with bun.lock was not detected as Bun.");
+            }
+            finally {
+                await rm(fixture, { recursive: true, force: true });
+            }
+        },
+    },
+    {
+        id: "context-relationship-ranking",
+        prompt: "Repository context ranking no longer includes a file connected to an independently relevant file. Restore relationship-aware ranking without replacing direct lexical ranking, add or update a focused test, and run relevant verification.",
+        seed: (workspace) => replacement(workspace, "src/application/context-selector.ts", "const relationshipScore = file.relatedFiles.some((path) => direct.has(path)) ? 3 : 0;", "const relationshipScore = 0;"),
+        async verify(workspace) {
+            const module = await import(pathToFileURL(join(workspace, "dist/application/context-selector.js")).href);
+            const selected = new module.ContextSelector().select("token", {
+                root: workspace,
+                packageManager: "pnpm",
+                scripts: {},
+                configFiles: [],
+                sourceRoots: [],
+                testRoots: [],
+                ignoredPaths: [],
+                indexedFiles: ["src/entry.ts", "src/token.ts", "src/other.ts"],
+                files: [
+                    {
+                        path: "src/entry.ts",
+                        terms: [],
+                        symbols: [],
+                        imports: [],
+                        relatedFiles: ["src/token.ts"],
+                    },
+                    {
+                        path: "src/token.ts",
+                        terms: ["token"],
+                        symbols: ["token"],
+                        imports: [],
+                        relatedFiles: [],
+                    },
+                    { path: "src/other.ts", terms: [], symbols: [], imports: [], relatedFiles: [] },
+                ],
+                verificationCandidates: [],
+                createdAt: 0,
+            });
+            if (!selected.includes("src/entry.ts"))
+                throw new Error("A related file was not ranked.");
+        },
+    },
+    {
+        id: "verifying-task-recovery",
+        prompt: "After a restart, tasks left in the verifying state are not recovered as interrupted. Restore durable restart recovery for that state, add or update a focused test, and run relevant verification.",
+        async seed(workspace) {
+            await replacement(workspace, "src/infrastructure/persistence/sqlite-session-store.ts", "status IN ('planning', 'acting', 'verifying')", "status IN ('planning', 'acting')");
+            await replacement(workspace, "src/infrastructure/persistence/sqlite-session-store.ts", "status IN ('planning', 'acting', 'verifying')", "status IN ('planning', 'acting')");
+        },
+        async verify(workspace) {
+            const directory = await mkdtemp(join(tmpdir(), "kairo-recovery-grader-"));
+            const fixture = join(directory, "state.sqlite");
+            const module = await import(pathToFileURL(join(workspace, "dist/infrastructure/persistence/sqlite-session-store.js"))
+                .href);
+            const first = await module.SqliteSessionStore.open(fixture);
+            const session = first.create(workspace);
+            const task = first.startTask(session.id, "Recover this task");
+            first.updateTask(task.id, { status: "verifying" });
+            first.close();
+            const resumed = await module.SqliteSessionStore.open(fixture);
+            try {
+                if (resumed.task(task.id)?.status !== "interrupted")
+                    throw new Error("A verifying task was not interrupted on restart.");
+            }
+            finally {
+                resumed.close();
+                await rm(directory, { recursive: true, force: true });
+            }
+        },
+    },
+    {
+        id: "symlink-escape-read",
+        prompt: "The workspace read tool accepts a symlink inside the workspace that points outside it. Restore symlink-escape protection for reads without weakening normal workspace access, add or update a focused test, and run relevant verification.",
+        seed: (workspace) => replacement(workspace, "src/infrastructure/tools/workspace-tools.ts", '      const actual = await realpath(candidate);\n      // Resolving first catches a path that looks local but exits through a symlink.\n      if (!this.inside(actual)) throw new Error("Symlink escapes the workspace.");\n      return actual;', "    return candidate;"),
+        async verify(workspace) {
+            const root = await mkdtemp(join(tmpdir(), "kairo-workspace-grader-"));
+            const outside = await mkdtemp(join(tmpdir(), "kairo-outside-grader-"));
+            try {
+                await writeFile(join(outside, "secret.txt"), "not for the workspace\n");
+                await symlink(outside, join(root, "escape"));
+                const module = await import(pathToFileURL(join(workspace, "dist/infrastructure/tools/workspace-tools.js")).href);
+                const result = await (await module.WorkspaceTools.create(root)).execute({ id: "read", name: "read_file", args: { path: "escape/secret.txt" } });
+                if (result.ok || !result.output.includes("Symlink escapes the workspace."))
+                    throw new Error("A read through an escaping symlink was accepted.");
+            }
+            finally {
+                await Promise.all([
+                    rm(root, { recursive: true, force: true }),
+                    rm(outside, { recursive: true, force: true }),
+                ]);
+            }
+        },
+    },
+    {
+        id: "repair-brief-evidence",
+        prompt: "The focused retry context omits extracted failure excerpts from the repair brief. Restore that evidence while preserving the summary and locations, add or update a focused test, and run relevant verification.",
+        seed: (workspace) => replacement(workspace, "src/application/context-manager.ts", '      `Evidence: ${latest.evidence.excerpts.join(" | ") || "inspect the command output"}`,\n', ""),
+        async verify(workspace) {
+            const store = await SqliteSessionStore.open(":memory:");
+            try {
+                const session = store.create(workspace);
+                const task = store.startTask(session.id, "Fix failure");
+                store.recordRepairAttempt({
+                    id: "repair-evidence",
+                    taskId: task.id,
+                    command: "pnpm test",
+                    evidence: {
+                        summary: "Expected true but received false",
+                        fileLocations: [{ path: "src/example.ts", line: 4 }],
+                        excerpts: ["Expected true", "received false"],
+                    },
+                    selectedFiles: ["src/example.ts"],
+                    createdAt: Date.now(),
+                });
+                const module = await import(pathToFileURL(join(workspace, "dist/application/context-manager.js")).href);
+                const brief = (await new module.ContextManager(store).prepare(session.id, task)).find((message) => message.content.startsWith("Repair attempt"))?.content;
+                if (!brief?.includes("Evidence: Expected true | received false"))
+                    throw new Error("The repair brief did not preserve evidence.");
+            }
+            finally {
+                store.close();
+            }
+        },
+    },
+];
+/** Runs real provider-backed tasks against clean Git-free snapshots and persists metadata-only evidence. */
+export async function runSelfEvaluationSuite(options) {
+    const sourceRoot = options.sourceRoot ?? process.cwd();
+    await assertKairoSource(sourceRoot);
+    const trials = options.trials ?? 1;
+    if (!Number.isInteger(trials) || trials < 1 || trials > 5)
+        throw new Error("Self-evaluation trials must be an integer from 1 to 5.");
+    let run = options.evaluationStore.createEvaluationRun({
+        suite: "self",
+        provider: options.provider,
+        model: options.model,
+        sourceRevision: await sourceRevision(sourceRoot),
+        trialCount: trials,
+        startedAt: Date.now(),
+        completedAt: undefined,
+    });
+    const results = [];
+    try {
+        for (let trial = 1; trial <= trials; trial += 1)
+            for (const scenario of selfEvaluationScenarios) {
+                const startedAt = Date.now();
+                const result = await runScenario(sourceRoot, scenario, options, trial);
+                results.push(result);
+                options.evaluationStore.saveEvaluationAttempt(toAttempt(run.id, result, startedAt));
+            }
+    }
+    finally {
+        run = options.evaluationStore.completeEvaluationRun(run.id);
+    }
+    return { run, results };
+}
+async function prepareWorkspace(sourceRoot, scenario) {
+    const workspace = await mkdtemp(join(tmpdir(), `kairo-self-eval-${scenario.id}-`));
+    await cp(sourceRoot, workspace, {
+        recursive: true,
+        filter: (source) => ![".git", "node_modules", "dist", ".kairo", ".pnpm-store"].includes(basename(source)),
+    });
+    await assertCommand(workspace, ["install", "--offline", "--frozen-lockfile"]);
+    await scenario.seed(workspace);
+    return workspace;
+}
+async function runScenario(sourceRoot, scenario, options, trial) {
+    let workspace;
+    try {
+        workspace = await prepareWorkspace(sourceRoot, scenario);
+        const store = await SqliteSessionStore.open(":memory:");
+        try {
+            const session = store.create(workspace);
+            const tools = await WorkspaceTools.create(workspace);
+            store.saveRepositorySnapshot(session.id, await new RepositoryProfiler().profile(workspace));
+            const agent = new CodingAgent(createProvider({ provider: options.provider, model: options.model }, options.apiKey, definitions), store, tools, new FixtureApproval(), definitions, { provider: options.provider, model: options.model });
+            const failure = await runEvaluatedAgent(agent, session.id, scenario.prompt, options.onProgress);
+            const agentError = failure.error;
+            const task = agent.status(session.id);
+            let expectationPassed = false;
+            let error = agentError ?? task.error;
+            try {
+                if (!agentError) {
+                    await assertCommand(workspace, ["test"]);
+                    await scenario.verify(workspace);
+                    expectationPassed = true;
+                }
+            }
+            catch (gradingError) {
+                error = `Grading failed: ${gradingError.message}`;
+            }
+            const metrics = taskMetrics(store.taskEvents(task.id));
+            const verified = task.verificationPassed === true;
+            return {
+                id: scenario.id,
+                trial,
+                passed: task.status === "completed" && verified && expectationPassed,
+                taskStatus: task.status,
+                verified,
+                expectationPassed,
+                error,
+                failureCategory: failure.category,
+                metrics: { ...metrics },
+            };
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch (error) {
+        return {
+            id: scenario.id,
+            trial,
+            passed: false,
+            taskStatus: "failed",
+            verified: false,
+            expectationPassed: false,
+            error: error.message,
+            failureCategory: "setup",
+            metrics: emptyMetrics(),
+        };
+    }
+    finally {
+        if (workspace)
+            await rm(workspace, { recursive: true, force: true });
+    }
+}
+function toAttempt(runId, result, startedAt) {
+    return {
+        runId,
+        scenarioId: result.id,
+        trial: result.trial,
+        passed: result.passed,
+        taskStatus: result.taskStatus,
+        verified: result.verified,
+        expectationPassed: result.expectationPassed,
+        failureCategory: result.passed ? undefined : classifyFailure(result),
+        metrics: result.metrics,
+        durationMs: Date.now() - startedAt,
+        createdAt: Date.now(),
+    };
+}
+function classifyFailure(result) {
+    if (result.failureCategory)
+        return result.failureCategory;
+    if (result.error?.startsWith("Grading failed:"))
+        return "grader";
+    if (result.error?.includes("Self-eval seed") || result.error?.includes("pnpm install"))
+        return "setup";
+    if (!result.verified)
+        return "verification";
+    if (result.taskStatus === "failed")
+        return "agent";
+    return "unknown";
+}
+class FixtureApproval {
+    async approve(_call, _description) {
+        return true;
+    }
+}
+function assertCommand(workspace, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("pnpm", args, { cwd: workspace, stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        const collect = (chunk) => {
+            output = `${output}${chunk}`.slice(-12_000);
+        };
+        child.stdout.on("data", collect);
+        child.stderr.on("data", collect);
+        const timer = setTimeout(() => child.kill("SIGTERM"), 120_000);
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            code === 0
+                ? resolve()
+                : reject(new Error(`pnpm ${args.join(" ")} exited with ${code}: ${output}`));
+        });
+    });
+}
+function sourceRevision(root) {
+    return new Promise((resolve) => {
+        const child = spawn("git", ["rev-parse", "--short=12", "HEAD"], {
+            cwd: root,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        let value = "";
+        child.stdout.on("data", (chunk) => (value += chunk));
+        child.once("error", () => resolve("unknown"));
+        child.once("close", (code) => resolve(code === 0 && value.trim() ? value.trim() : "unknown"));
+    });
+}
+async function assertKairoSource(root) {
+    try {
+        const packageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+        await readFile(join(root, "src/application/coding-agent.ts"), "utf8");
+        if (packageJson.name !== "kairo")
+            throw new Error();
+    }
+    catch {
+        throw new Error("Run `kairo eval self` from the Kairo repository root.");
+    }
+}
+function emptyMetrics() {
+    return {
+        modelTurns: 0,
+        toolExecutions: 0,
+        toolFailures: 0,
+        approvals: 0,
+        repairs: 0,
+        verificationPasses: 0,
+        verificationFailures: 0,
+        verificationSelections: 0,
+        focusedVerifications: 0,
+        broadVerifications: 0,
+        repairConverged: false,
+        modelMs: 0,
+        toolMs: 0,
+    };
+}

package/dist/application/task-metrics.d.ts

@@ -0,0 +1,31 @@
+import type { TaskEvent } from "../domain/models.js";
+/** Derives counters from durable events so resume never resets or doubles stored totals. */
+export declare function taskMetrics(events: TaskEvent[]): {
+    providerRetries: number;
+    providerWaitMs: number;
+    modelTurns: number;
+    modelFailures: number;
+    modelMs: number;
+    toolRequests: number;
+    toolExecutions: number;
+    toolFailures: number;
+    toolMs: number;
+    approvals: number;
+    denials: number;
+    approvalMs: number;
+    autonomousActions: number;
+    repairs: number;
+    verificationPasses: number;
+    verificationFailures: number;
+    verificationSelections: number;
+    focusedVerifications: number;
+    broadVerifications: number;
+    jevDecisions: number;
+    jevFailures: number;
+    jevMs: number;
+    jevRoutes: number;
+    jevSafetyChecks: number;
+    jevRecoveryChecks: number;
+    repairConverged: boolean;
+    unfinishedOperations: number;
+};

package/dist/application/task-metrics.js

@@ -0,0 +1,42 @@
+/** Derives counters from durable events so resume never resets or doubles stored totals. */
+export function taskMetrics(events) {
+    const count = (kind, outcome) => events.filter((event) => event.kind === kind && (!outcome || event.outcome === outcome)).length;
+    const duration = (kind) => events
+        .filter((event) => event.kind === kind)
+        .reduce((sum, event) => sum + (event.durationMs ?? 0), 0);
+    const started = events.filter((event) => event.kind === "model_started" || event.kind === "tool_started");
+    const unfinished = started.filter((event) => !events.some((end) => end.operationId === event.operationId &&
+        end.kind === (event.kind === "model_started" ? "model_finished" : "tool_finished")));
+    return {
+        providerRetries: count("provider_retry"),
+        providerWaitMs: duration("provider_retry_wait"),
+        modelTurns: count("model_started"),
+        modelFailures: count("model_finished", "failed"),
+        modelMs: duration("model_finished"),
+        toolRequests: count("tool_requested"),
+        toolExecutions: count("tool_started"),
+        toolFailures: count("tool_finished", "failed"),
+        toolMs: duration("tool_finished"),
+        approvals: count("approval", "approved"),
+        denials: count("approval", "denied"),
+        approvalMs: duration("approval"),
+        autonomousActions: count("autonomous"),
+        repairs: count("repair"),
+        verificationPasses: count("verification", "passed"),
+        verificationFailures: count("verification", "failed"),
+        verificationSelections: count("verification_selected"),
+        focusedVerifications: count("verification_selected", "focused"),
+        broadVerifications: count("verification_selected", "broad"),
+        jevDecisions: count("jev_completed"),
+        jevFailures: count("jev_failed"),
+        jevMs: duration("jev_completed") + duration("jev_failed"),
+        jevRoutes: events.filter((event) => event.kind === "jev_completed" && event.name === "route")
+            .length,
+        jevSafetyChecks: events.filter((event) => event.kind === "jev_completed" && event.name === "safety").length,
+        jevRecoveryChecks: events.filter((event) => event.kind === "jev_completed" && event.name === "recovery").length,
+        repairConverged: events.some((event) => event.kind === "repair") &&
+            events.findLast((event) => event.kind === "verification")?.outcome === "passed" &&
+            events.findLast((event) => event.kind === "status")?.outcome === "completed",
+        unfinishedOperations: unfinished.length,
+    };
+}

package/dist/application/verification-planner.d.ts

@@ -0,0 +1,12 @@
+import type { FailureEvidence, RepositorySnapshot, VerificationCandidate, VerificationSelection } from "../domain/models.js";
+export declare class VerificationPlanner {
+    /** Converts recognized package scripts into safe, ordered verification suggestions. */
+    candidates(profile: Pick<RepositorySnapshot, "packageManager" | "scripts"> & Partial<Pick<RepositorySnapshot, "manifestFiles">>): VerificationCandidate[];
+    private lockfile;
+    /** Selects the narrowest known check that plausibly covers changed or failing files. */
+    select(profile: Pick<RepositorySnapshot, "sourceRoots" | "testRoots" | "configFiles" | "verificationCandidates">, changedFiles: string[], failure?: FailureEvidence): VerificationSelection | undefined;
+    /** Labels a command chosen outside the recommender without rejecting manual or model fallback. */
+    selectionForCommand(profile: Pick<RepositorySnapshot, "verificationCandidates"> | undefined, command: string, source: Exclude<VerificationSelection["source"], "recommended">): VerificationSelection;
+    /** Returns a broader project check only after a focused recommendation has passed. */
+    broader(profile: Pick<RepositorySnapshot, "verificationCandidates">, completed: VerificationSelection): VerificationSelection | undefined;
+}

package/dist/application/verification-planner.js

@@ -0,0 +1,97 @@
+const labels = [
+    ["test", ["test", "test:unit", "test:run"]],
+    ["typecheck", ["typecheck", "type-check", "check"]],
+    ["lint", ["lint"]],
+    ["build", ["build"]],
+];
+export class VerificationPlanner {
+    /** Converts recognized package scripts into safe, ordered verification suggestions. */
+    candidates(profile) {
+        const runner = profile.packageManager === "unknown" ? "npm run" : profile.packageManager;
+        const candidate = [];
+        for (const [label, names] of labels) {
+            const script = names.find((name) => profile.scripts[name]);
+            if (script)
+                candidate.push({
+                    label,
+                    command: runner === "npm run" ? `npm run ${script}` : `${runner} ${script}`,
+                    scope: "broad",
+                    reason: `Discovered ${script} package script.`,
+                    evidence: [
+                        {
+                            path: profile.manifestFiles?.find((path) => path.endsWith("package.json")) ??
+                                "package.json",
+                            kind: "manifest",
+                        },
+                        ...(profile.packageManager === "unknown"
+                            ? []
+                            : [{ path: this.lockfile(profile.packageManager), kind: "lockfile" }]),
+                    ],
+                });
+        }
+        return candidate;
+    }
+    lockfile(packageManager) {
+        return {
+            npm: "package-lock.json",
+            pnpm: "pnpm-lock.yaml",
+            yarn: "yarn.lock",
+            bun: "bun.lock",
+        }[packageManager];
+    }
+    /** Selects the narrowest known check that plausibly covers changed or failing files. */
+    select(profile, changedFiles, failure) {
+        const candidates = profile.verificationCandidates;
+        if (!candidates.length)
+            return undefined;
+        const changed = [
+            ...new Set([
+                ...changedFiles,
+                ...(failure ? failure.fileLocations.map((item) => item.path) : []),
+            ]),
+        ];
+        const byLabel = (label) => candidates.find((candidate) => candidate.label === label);
+        const selection = (candidate, scope, reason) => candidate && {
+            command: candidate.command,
+            label: candidate.label,
+            scope,
+            reason,
+            source: "recommended",
+        };
+        const isTest = changed.some((path) => profile.testRoots.some((root) => path === root || path.startsWith(`${root}/`)) ||
+            /(?:^|[./_-])(test|spec)(?:[._-]|$)/i.test(path));
+        if (isTest)
+            return selection(byLabel("test"), "broad", "Changed or failing test file is covered by the test script.");
+        const isSource = changed.some((path) => profile.sourceRoots.some((root) => path === root || path.startsWith(`${root}/`)));
+        if (isSource && byLabel("typecheck"))
+            return selection(byLabel("typecheck"), "broad", "Changed source file is covered by typechecking.");
+        const isConfig = changed.some((path) => profile.configFiles.includes(path) || /(?:^|\/)(?:package|tsconfig)\.json$/.test(path));
+        if (isConfig)
+            return selection(byLabel("test") ?? byLabel("typecheck"), "broad", "Configuration change needs a project-level check.");
+        return selection(byLabel("test") ?? byLabel("typecheck") ?? candidates[0], "broad", "No narrower coverage could be established.");
+    }
+    /** Labels a command chosen outside the recommender without rejecting manual or model fallback. */
+    selectionForCommand(profile, command, source) {
+        const candidate = profile?.verificationCandidates.find((item) => item.command === command);
+        return {
+            command,
+            label: candidate?.label ?? "custom",
+            scope: candidate?.scope ?? "broad",
+            reason: candidate?.reason ?? "Command selected outside automatic recommendation.",
+            source,
+        };
+    }
+    /** Returns a broader project check only after a focused recommendation has passed. */
+    broader(profile, completed) {
+        const candidate = profile.verificationCandidates.find((item) => item.label === "test" && item.command !== completed.command);
+        if (!candidate)
+            return undefined;
+        return {
+            command: candidate.command,
+            label: candidate.label,
+            scope: "broad",
+            reason: "Typechecking passed; run the project tests for behavioral coverage.",
+            source: "recommended",
+        };
+    }
+}