@dailephd/my-dev-kit-lab 0.2.0

package/dist/scripts/security/runPackageChecks.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { runPackageChecks } from "../../src/securityValidation/index.js";
+import { DEFAULT_SECURITY_CONFIG } from "../../src/securityValidation/index.js";
+import { resolveValidationTarget } from "../../src/securityValidation/validate/resolveTarget.js";
+const rawArgs = process.argv.slice(2);
+const args = parseArgs(rawArgs);
+const toolRoot = process.cwd();
+let targetRoot;
+try {
+    const target = resolveValidationTarget(args.target, toolRoot);
+    targetRoot = target.targetRoot;
+    if (!target.isSelf) {
+        console.log(`Target: ${targetRoot}`);
+    }
+}
+catch (err) {
+    console.error(`ERROR: ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 1;
+    process.exit(1);
+}
+const config = {
+    ...DEFAULT_SECURITY_CONFIG,
+    reportDir: path.join(toolRoot, DEFAULT_SECURITY_CONFIG.reportDir),
+    rawOutputDir: path.join(toolRoot, DEFAULT_SECURITY_CONFIG.rawOutputDir),
+};
+console.log("Running package content checks...");
+console.log(`Report directory: ${config.reportDir}`);
+const output = await runPackageChecks({ cwd: targetRoot, config });
+const passed = output.checks.filter((c) => c.status === "passed").length;
+const failed = output.checks.filter((c) => c.status === "failed").length;
+const warned = output.checks.filter((c) => c.status === "warning").length;
+console.log(`\nPackage checks complete:`);
+console.log(`  Passed:  ${passed}`);
+console.log(`  Warned:  ${warned}`);
+console.log(`  Failed:  ${failed}`);
+console.log(`  Findings: ${output.findings.length}`);
+if (output.findings.length > 0) {
+    console.log("\nFindings:");
+    for (const f of output.findings) {
+        console.log(`  [${f.severity.toUpperCase()}] ${f.title}`);
+    }
+}
+console.log(`\nResults written to ${config.reportDir}`);
+const hasBlocker = output.findings.some((f) => f.severity === "blocker");
+const hasMajor = output.findings.some((f) => f.severity === "major");
+process.exitCode = hasBlocker || hasMajor ? 1 : 0;
+function parseArgs(argv) {
+    const result = {};
+    for (let i = 0; i < argv.length; i++) {
+        if ((argv[i] === "--target" || argv[i] === "-t") && i + 1 < argv.length) {
+            result.target = argv[++i];
+        }
+    }
+    return result;
+}

package/dist/scripts/security/runSemgrep.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { runSemgrepCheck } from "../../src/securityValidation/staticScans/semgrep.js";
+import { resolveValidationTarget } from "../../src/securityValidation/validate/resolveTarget.js";
+const rawArgs = process.argv.slice(2);
+const args = parseArgs(rawArgs);
+const toolRoot = process.cwd();
+let targetRoot;
+try {
+    const target = resolveValidationTarget(args.target, toolRoot);
+    targetRoot = target.targetRoot;
+    if (!target.isSelf) {
+        console.log(`Target: ${targetRoot}`);
+    }
+}
+catch (err) {
+    console.error(`ERROR: ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 1;
+    process.exit(1);
+}
+console.log("Running Semgrep static analysis check...");
+console.log(`Config: ${path.join(toolRoot, ".semgrep.yml")}`);
+const result = await runSemgrepCheck({
+    targetRoot,
+    toolRoot,
+    configPath: path.join(toolRoot, ".semgrep.yml"),
+    timeoutMs: 120_000,
+});
+const label = result.status === "skipped"
+    ? `SKIPPED — ${result.skippedReason ?? "tool unavailable"}`
+    : result.status.toUpperCase();
+console.log(`\nStatus: ${label}`);
+if (result.findings.length > 0) {
+    console.log("\nFindings:");
+    for (const f of result.findings) {
+        console.log(`  [${f.severity.toUpperCase()}] ${f.title}`);
+        if (f.affectedFiles && f.affectedFiles.length > 0) {
+            console.log(`    Location: ${f.affectedFiles[0]}`);
+        }
+        if (f.description)
+            console.log(`    ${f.description.slice(0, 120)}`);
+    }
+}
+console.log(`\nDuration: ${result.durationMs}ms`);
+if (result.status === "skipped") {
+    console.log("\nSemgrep is optional. Absence does not block release.");
+    process.exitCode = 0;
+}
+else if (result.status === "failed") {
+    process.exitCode = 1;
+}
+else {
+    process.exitCode = 0;
+}
+function parseArgs(argv) {
+    const result = {};
+    for (let i = 0; i < argv.length; i++) {
+        if ((argv[i] === "--target" || argv[i] === "-t") && i + 1 < argv.length) {
+            result.target = argv[++i];
+        }
+    }
+    return result;
+}

package/dist/scripts/security/validate.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import path from "node:path";
+import fs from "node:fs";
+import { runSecurityValidation } from "../../src/securityValidation/validate/runSecurityValidation.js";
+import { resolveValidationTarget, reportFilenamePrefix } from "../../src/securityValidation/validate/resolveTarget.js";
+import { renderTextReport, renderJsonReport } from "../../src/securityValidation/report/renderSecurityReport.js";
+// Parse CLI arguments from process.argv (after the node/tsx and script path).
+const rawArgs = process.argv.slice(2);
+const args = parseArgs(rawArgs);
+const toolRoot = process.cwd();
+// Resolve and validate target early so we can fail fast with a clean error.
+let target;
+try {
+    target = resolveValidationTarget(args.target, toolRoot);
+}
+catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`\nERROR: ${msg}`);
+    console.error("Usage: npm run security:validate -- [--target <path>] [--out <dir>] [--report-prefix <name>]");
+    process.exitCode = 1;
+    process.exit(1);
+}
+console.log("=".repeat(60));
+console.log("my-dev-kit-lab security:validate");
+console.log("=".repeat(60));
+console.log(`Tool root  : ${toolRoot}`);
+if (!target.isSelf) {
+    console.log(`Target     : ${target.targetRoot}`);
+    if (target.packageName)
+        console.log(`Package    : ${target.packageName}${target.packageVersion ? `@${target.packageVersion}` : ""}`);
+}
+else {
+    console.log(`Mode       : self-validation`);
+}
+console.log("");
+const summary = await runSecurityValidation({
+    cwd: toolRoot,
+    targetPath: args.target,
+    fuzzIterations: parseInt(process.env["FUZZ_ITERATIONS"] ?? "50", 10),
+    fuzzSeed: parseInt(process.env["FUZZ_SEED"] ?? "0xDEADBEEF", 16),
+});
+// Build report object
+const report = {
+    metadata: {
+        toolRoot: summary.toolRoot,
+        toolPackageName: summary.toolPackageName,
+        toolPackageVersion: summary.toolPackageVersion,
+        targetRoot: summary.targetRoot,
+        targetDescription: summary.targetDescription,
+        packageName: summary.packageName,
+        packageVersion: summary.packageVersion,
+        branch: summary.auditedBranch,
+        commit: summary.auditedCommit,
+        isSelf: summary.isSelf,
+        generatedAt: summary.finishedAt,
+        totalDurationMs: new Date(summary.finishedAt).getTime() - new Date(summary.startedAt).getTime(),
+    },
+    sections: [],
+    allChecks: summary.checks,
+    allFindings: summary.findings,
+    verdict: summary.verdict,
+    recommendedNextStep: summary.recommendedNextStep,
+};
+const textReport = renderTextReport(report);
+const jsonReport = renderJsonReport(report);
+// Determine output directory
+const reportsDir = args.out
+    ? path.resolve(args.out)
+    : path.join(toolRoot, "reports", "security");
+if (!fs.existsSync(reportsDir)) {
+    fs.mkdirSync(reportsDir, { recursive: true });
+}
+// Determine report filename prefix
+const prefix = args.reportPrefix ?? reportFilenamePrefix(target);
+const txtPath = path.join(reportsDir, `${prefix}-security-validation.txt`);
+const jsonPath = path.join(reportsDir, `${prefix}-security-validation.json`);
+fs.writeFileSync(txtPath, textReport, "utf8");
+fs.writeFileSync(jsonPath, jsonReport, "utf8");
+// Print report to stdout
+console.log(textReport);
+console.log(`\nReports written:`);
+console.log(`  ${txtPath}`);
+console.log(`  ${jsonPath}`);
+// Exit code based on verdict
+const blockerExists = summary.verdict === "not-ready-security-blocker-remains";
+const inconclusive = summary.verdict === "inconclusive-audit-environment-incomplete";
+if (blockerExists) {
+    console.error("\nExit 1 — security blocker remains.");
+    process.exitCode = 1;
+}
+else if (inconclusive) {
+    console.warn("\nExit 2 — audit environment incomplete.");
+    process.exitCode = 2;
+}
+else {
+    console.log("\nExit 0 — validation completed.");
+    process.exitCode = 0;
+}
+// ---------------------------------------------------------------------------
+// Argument parser
+// ---------------------------------------------------------------------------
+function parseArgs(argv) {
+    const result = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if ((arg === "--target" || arg === "-t") && i + 1 < argv.length) {
+            result.target = argv[++i];
+        }
+        else if (arg === "--out" && i + 1 < argv.length) {
+            result.out = argv[++i];
+        }
+        else if (arg === "--report-prefix" && i + 1 < argv.length) {
+            result.reportPrefix = argv[++i];
+        }
+    }
+    return result;
+}

package/dist/scripts/verify-benchmarks.js

@@ -0,0 +1,202 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { REQUIRED_BENCHMARK_PROJECT_IDS, parseBenchmarkProjectProfiles, validateAnswerKey, validateBenchmarkProjectProfiles } from "../src/evaluation/benchmarkMetadata.js";
+const requiredProjects = REQUIRED_BENCHMARK_PROJECT_IDS;
+const projectRequiredPaths = {
+    "todo-ts": [
+        "README.md",
+        "package.json",
+        "tsconfig.json",
+        "src/taskStore.ts",
+        "src/taskService.ts",
+        "src/index.ts",
+        "tests/taskService.test.ts"
+    ],
+    "todo-python": [
+        "README.md",
+        "src/task_store.py",
+        "src/task_service.py",
+        "src/__init__.py",
+        "tests/test_task_service.py"
+    ],
+    "todo-js": [
+        "README.md",
+        "package.json",
+        "src/taskStore.js",
+        "src/taskService.js",
+        "src/index.js",
+        "tests/taskService.test.js"
+    ],
+    "todo-mixed-ts-py": [
+        "README.md",
+        "package.json",
+        "tsconfig.json",
+        "src/taskCli.ts",
+        "python/task_service.py",
+        "tests/mixedBoundary.test.ts"
+    ],
+    "task-workflow-medium-ts": [
+        "README.md",
+        "package.json",
+        "tsconfig.json",
+        "src/store/taskStore.ts",
+        "src/services/createTask.ts",
+        "src/services/importTasks.ts",
+        "src/services/summarizeTasks.ts",
+        "tests/importTasks.test.ts"
+    ],
+    "task-analytics-large-mixed": [
+        "README.md",
+        "ts/package.json",
+        "ts/tsconfig.json",
+        "ts/src/services/buildAnalyticsSnapshot.ts",
+        "ts/src/reporting/formatTaskHealthReport.ts",
+        "ts/tests/buildAnalyticsSnapshot.test.ts",
+        "py/task_analytics/metrics.py",
+        "py/task_analytics/quality.py",
+        "py/tests/test_reporting.py"
+    ]
+};
+function walk(dir) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walk(fullPath));
+        }
+        else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+export function validateBenchmarks(rootDir = process.cwd()) {
+    const checks = [];
+    const errors = [];
+    const contractsDir = path.join(rootDir, "benchmarks", "contracts");
+    const projectsDir = path.join(rootDir, "benchmarks", "projects");
+    const behaviorPath = path.join(contractsDir, "todo-behavior.md");
+    const casesPath = path.join(contractsDir, "todo-benchmark-case.json");
+    const profilesPath = path.join(contractsDir, "benchmark-project-profiles.json");
+    if (!existsSync(behaviorPath)) {
+        errors.push("Missing contract file: benchmarks/contracts/todo-behavior.md");
+    }
+    else {
+        checks.push("found todo-behavior.md");
+    }
+    let cases = [];
+    if (!existsSync(casesPath)) {
+        errors.push("Missing contract file: benchmarks/contracts/todo-benchmark-case.json");
+    }
+    else {
+        try {
+            cases = JSON.parse(readFileSync(casesPath, "utf8"));
+            checks.push("parsed todo-benchmark-case.json");
+        }
+        catch (error) {
+            errors.push(`Invalid JSON in todo-benchmark-case.json: ${error.message}`);
+        }
+    }
+    if (!existsSync(profilesPath)) {
+        errors.push("Missing contract file: benchmarks/contracts/benchmark-project-profiles.json");
+    }
+    else {
+        try {
+            const profiles = parseBenchmarkProjectProfiles(JSON.parse(readFileSync(profilesPath, "utf8")));
+            const profileErrors = validateBenchmarkProjectProfiles(profiles, rootDir);
+            errors.push(...profileErrors);
+            if (profileErrors.length === 0) {
+                checks.push("validated benchmark-project-profiles.json");
+            }
+        }
+        catch (error) {
+            errors.push(`Invalid benchmark-project-profiles.json: ${error.message}`);
+        }
+    }
+    const ids = new Set();
+    for (const benchmarkCase of cases) {
+        if (ids.has(benchmarkCase.id)) {
+            errors.push(`Duplicate benchmark case id: ${benchmarkCase.id}`);
+        }
+        ids.add(benchmarkCase.id);
+    }
+    if (cases.length > 0 && errors.every((error) => !error.startsWith("Duplicate benchmark case id:"))) {
+        checks.push("benchmark case ids are unique");
+    }
+    for (const project of requiredProjects) {
+        const projectDir = path.join(projectsDir, project);
+        if (!existsSync(projectDir) || !statSync(projectDir).isDirectory()) {
+            errors.push(`Missing benchmark project: benchmarks/projects/${project}`);
+            continue;
+        }
+        checks.push(`found benchmark project ${project}`);
+        for (const relPath of projectRequiredPaths[project]) {
+            const fullPath = path.join(projectDir, relPath);
+            if (!existsSync(fullPath)) {
+                errors.push(`Missing required file for ${project}: benchmarks/projects/${project}/${relPath}`);
+            }
+        }
+    }
+    for (const benchmarkCase of cases) {
+        if (!benchmarkCase.answerKey) {
+            errors.push(`Case ${benchmarkCase.id} does not define answerKey`);
+        }
+        else {
+            errors.push(...validateAnswerKey(benchmarkCase.answerKey, `Case ${benchmarkCase.id}`));
+        }
+        if (!Array.isArray(benchmarkCase.expectedSymbols) || benchmarkCase.expectedSymbols.length === 0) {
+            errors.push(`Case ${benchmarkCase.id} does not define expectedSymbols`);
+        }
+        for (const [project, expectedFiles] of Object.entries(benchmarkCase.expectedFilesByProject ?? {})) {
+            if (!requiredProjects.includes(project)) {
+                errors.push(`Case ${benchmarkCase.id} references unknown project id: ${project}`);
+                continue;
+            }
+            if (!Array.isArray(expectedFiles) || expectedFiles.length === 0) {
+                errors.push(`Case ${benchmarkCase.id} does not define expected files for ${project}`);
+                continue;
+            }
+            for (const expectedFile of expectedFiles) {
+                const fullPath = path.join(rootDir, "benchmarks", "projects", project, expectedFile);
+                if (!existsSync(fullPath)) {
+                    errors.push(`Case ${benchmarkCase.id} references missing file: benchmarks/projects/${project}/${expectedFile}`);
+                }
+            }
+        }
+    }
+    for (const project of requiredProjects) {
+        const projectDir = path.join(projectsDir, project);
+        if (!existsSync(projectDir)) {
+            continue;
+        }
+        const forbidden = walk(projectDir).filter((fullPath) => {
+            const rel = path.relative(projectDir, fullPath).replace(/\\/g, "/");
+            return /(^|\/)(node_modules|dist|build|coverage|lab-output)(\/|$)/.test(rel);
+        });
+        if (forbidden.length > 0) {
+            errors.push(`Forbidden generated output found in ${project}: ${forbidden[0]}`);
+        }
+    }
+    return { ok: errors.length === 0, errors, checks };
+}
+function printSummary(result) {
+    console.log(`Benchmark verification ${result.ok ? "passed" : "failed"}.`);
+    console.log(`Checks: ${result.checks.length}`);
+    if (result.errors.length > 0) {
+        console.log(`Errors: ${result.errors.length}`);
+        for (const error of result.errors) {
+            console.log(`- ${error}`);
+        }
+    }
+}
+const currentFile = fileURLToPath(import.meta.url);
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : "";
+if (invokedPath === currentFile) {
+    const result = validateBenchmarks();
+    printSummary(result);
+    if (!result.ok) {
+        process.exitCode = 1;
+    }
+}

package/dist/src/agents/adapters/claudeAdapter.js

@@ -0,0 +1,37 @@
+import { runCliAgent } from "./codexAdapter.js";
+import { applyPromptToCommandTemplate } from "../runAgentPrompt.js";
+import { parseAgentTokenUsage } from "../parseAgentTokenUsage.js";
+import { runMeasuredCommand } from "../../core/runMeasuredCommand.js";
+export const claudeAdapter = {
+    id: "claude",
+    displayName: "Claude",
+    surface: "cli",
+    async isAvailable(request) {
+        if (request.commandTemplate) {
+            return true;
+        }
+        const check = await runMeasuredCommand({
+            commandId: "claude-availability",
+            commandString: "claude",
+            extraArgs: ["--version"],
+            cwd: request.cwd,
+            outDir: request.outDir,
+            env: request.env
+        });
+        return check.ok;
+    },
+    buildCommand(request) {
+        if (request.commandTemplate) {
+            return applyPromptToCommandTemplate(request.commandTemplate, request.promptText);
+        }
+        return { command: "claude", args: ["-p", request.promptText] };
+    },
+    async runPrompt(request) {
+        return runCliAgent(request, this);
+    },
+    parseTokenUsage: parseAgentTokenUsage,
+    parseFinalAnswer(text) {
+        const trimmed = text.trim();
+        return { finalAnswerText: trimmed, finalAnswerParseStatus: trimmed ? "parsed" : "empty" };
+    }
+};

package/dist/src/agents/adapters/codexAdapter.js

@@ -0,0 +1,110 @@
+import { runMeasuredCommand } from "../../core/runMeasuredCommand.js";
+import { applyPromptToCommandTemplate } from "../runAgentPrompt.js";
+import { parseAgentTokenUsage } from "../parseAgentTokenUsage.js";
+export const codexAdapter = {
+    id: "codex",
+    displayName: "Codex",
+    surface: "cli",
+    async isAvailable(request) {
+        if (request.commandTemplate) {
+            return true;
+        }
+        const check = await runMeasuredCommand({
+            commandId: "codex-availability",
+            commandString: "codex",
+            extraArgs: ["--version"],
+            cwd: request.cwd,
+            outDir: request.outDir,
+            env: request.env
+        });
+        return check.ok;
+    },
+    buildCommand(request) {
+        if (request.commandTemplate) {
+            return applyPromptToCommandTemplate(request.commandTemplate, request.promptText);
+        }
+        return { command: "codex", args: ["exec", "--json", request.promptText] };
+    },
+    async runPrompt(request) {
+        return runCliAgent(request, this);
+    },
+    parseTokenUsage: parseAgentTokenUsage,
+    parseFinalAnswer(text) {
+        const trimmed = text.trim();
+        return { finalAnswerText: trimmed, finalAnswerParseStatus: trimmed ? "parsed" : "empty" };
+    }
+};
+export async function runCliAgent(request, adapter) {
+    const started = Date.now();
+    const command = adapter.buildCommand(request);
+    const available = await adapter.isAvailable(request);
+    if (!available) {
+        const ended = Date.now();
+        const status = request.requireAvailable ? "failed" : "skipped";
+        const message = `${adapter.displayName} CLI was not available.`;
+        return {
+            runId: request.runId,
+            agentId: adapter.id,
+            displayName: adapter.displayName,
+            surface: adapter.surface,
+            promptVariantId: request.promptVariant.id,
+            promptStrategy: request.promptVariant.strategy,
+            promptComplexityLevel: request.promptVariant.complexityLevel,
+            startedAt: new Date(started).toISOString(),
+            endedAt: new Date(ended).toISOString(),
+            durationMs: ended - started,
+            status,
+            exitCode: null,
+            command: command.command,
+            args: command.args,
+            cwd: request.cwd,
+            finalAnswerText: "",
+            finalAnswerParseStatus: "empty",
+            tokenUsage: { source: "unavailable" },
+            tokenUsageSource: "unavailable",
+            tokenUsageReliability: "unavailable",
+            warnings: status === "skipped" ? [message] : [],
+            errors: status === "failed" ? [message] : []
+        };
+    }
+    const measured = await runMeasuredCommand({
+        commandId: `${adapter.id}-agent-run`,
+        commandString: command.command,
+        extraArgs: command.args,
+        cwd: request.commandTemplate?.cwd ?? request.cwd,
+        outDir: request.outDir,
+        env: request.env,
+        timeoutMs: request.timeoutMs
+    });
+    const ended = Date.now();
+    const combinedOutput = `${measured.stdout}\n${measured.stderr}`;
+    const parsedAnswer = adapter.parseFinalAnswer(measured.stdout || measured.stderr);
+    const parsedUsage = adapter.parseTokenUsage(combinedOutput);
+    return {
+        runId: request.runId,
+        agentId: adapter.id,
+        displayName: adapter.displayName,
+        surface: adapter.surface,
+        promptVariantId: request.promptVariant.id,
+        promptStrategy: request.promptVariant.strategy,
+        promptComplexityLevel: request.promptVariant.complexityLevel,
+        startedAt: new Date(started).toISOString(),
+        endedAt: new Date(ended).toISOString(),
+        durationMs: ended - started,
+        status: measured.ok ? "completed" : "failed",
+        exitCode: measured.exitCode,
+        command: measured.executable,
+        args: measured.args,
+        cwd: request.commandTemplate?.cwd ?? request.cwd,
+        stdoutPath: measured.stdoutPath,
+        stderrPath: measured.stderrPath,
+        telemetryPath: measured.telemetryPath,
+        finalAnswerText: parsedAnswer.finalAnswerText,
+        finalAnswerParseStatus: parsedAnswer.finalAnswerParseStatus,
+        tokenUsage: parsedUsage.tokenUsage,
+        tokenUsageSource: parsedUsage.tokenUsageSource,
+        tokenUsageReliability: parsedUsage.tokenUsageReliability,
+        warnings: parsedUsage.warnings,
+        errors: measured.ok ? [] : [measured.error ?? "Agent command failed."]
+    };
+}

package/dist/src/agents/adapters/fakeAgentAdapter.js

@@ -0,0 +1,101 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+export const fakeAgentAdapter = {
+    id: "fake-agent",
+    displayName: "Fake Agent",
+    surface: "simulated",
+    async isAvailable() {
+        return true;
+    },
+    buildCommand() {
+        return { command: "fake-agent", args: [] };
+    },
+    async runPrompt(request) {
+        const started = Date.now();
+        const mode = request.env?.FAKE_AGENT_MODE ?? "success";
+        await mkdir(request.outDir, { recursive: true });
+        const stdoutPath = path.join(request.outDir, "fake-agent.stdout.txt");
+        const stderrPath = path.join(request.outDir, "fake-agent.stderr.txt");
+        const telemetryPath = path.join(request.outDir, "fake-agent.telemetry.json");
+        const failed = mode === "failure";
+        const missingUsage = mode === "missing-token-usage";
+        const invalidOutput = mode === "invalid-output";
+        const finalAnswerText = invalidOutput ? "Simulated unstructured output without scoreable fields." : buildFakeAnswer(request, missingUsage);
+        await writeFile(stdoutPath, `${finalAnswerText}\n`, "utf8");
+        await writeFile(stderrPath, failed ? "Simulated fake-agent failure.\n" : "", "utf8");
+        const ended = Date.now();
+        const result = {
+            runId: request.runId,
+            agentId: "fake-agent",
+            displayName: "Fake Agent",
+            surface: "simulated",
+            promptVariantId: request.promptVariant.id,
+            promptStrategy: request.promptVariant.strategy,
+            promptComplexityLevel: request.promptVariant.complexityLevel,
+            startedAt: new Date(started).toISOString(),
+            endedAt: new Date(ended).toISOString(),
+            durationMs: ended - started,
+            status: failed ? "failed" : "completed",
+            exitCode: failed ? 1 : 0,
+            command: "fake-agent",
+            args: [],
+            cwd: request.cwd,
+            stdoutPath,
+            stderrPath,
+            telemetryPath,
+            finalAnswerText,
+            finalAnswerParseStatus: invalidOutput ? "empty" : "parsed",
+            tokenUsage: missingUsage
+                ? { source: "unavailable", rawText: finalAnswerText }
+                : {
+                    inputTokens: request.promptVariant.promptMetrics.promptEstimatedTokens,
+                    outputTokens: 128,
+                    totalTokens: request.promptVariant.promptMetrics.promptEstimatedTokens + 128,
+                    source: "agent-reported",
+                    rawText: finalAnswerText
+                },
+            tokenUsageSource: missingUsage ? "unavailable" : "agent-reported",
+            tokenUsageReliability: missingUsage ? "unavailable" : "high",
+            warnings: missingUsage ? ["Token usage was intentionally omitted by fake-agent mode."] : [],
+            errors: failed ? ["Simulated fake-agent failure."] : []
+        };
+        await writeFile(telemetryPath, `${JSON.stringify({ commandId: "fake-agent", exitCode: result.exitCode, durationMs: result.durationMs }, null, 2)}\n`, "utf8");
+        return result;
+    },
+    parseTokenUsage() {
+        return {
+            tokenUsage: { source: "agent-reported" },
+            tokenUsageSource: "agent-reported",
+            tokenUsageReliability: "high",
+            warnings: []
+        };
+    },
+    parseFinalAnswer(text) {
+        const trimmed = text.trim();
+        return {
+            finalAnswerText: trimmed,
+            finalAnswerParseStatus: trimmed ? "parsed" : "empty"
+        };
+    }
+};
+function buildFakeAnswer(request, missingUsage) {
+    const facts = request.promptVariant.expectedAnswerKey.expectedFacts.slice(0, 2).map((fact) => fact.id);
+    const tokenLines = missingUsage
+        ? ""
+        : [
+            `tokenUsage: inputTokens=${request.promptVariant.promptMetrics.promptEstimatedTokens}, outputTokens=128, totalTokens=${request.promptVariant.promptMetrics.promptEstimatedTokens + 128}`,
+            "tokenUsageSource: agent-reported"
+        ].join("\n");
+    return [
+        "answer: Simulated benchmark answer from fake-agent.",
+        `relevantFiles: ${request.promptVariant.expectedAnswerKey.expectedFiles.join(", ")}`,
+        `relevantSymbols: ${request.promptVariant.expectedAnswerKey.expectedSymbols.join(", ")}`,
+        `expectedFactsFound: ${facts.join(", ")}`,
+        "confidence: high",
+        tokenLines,
+        `executionTime: simulated-${request.promptVariant.complexityLevel}`,
+        "notes: Deterministic fake-agent output for tests."
+    ]
+        .filter(Boolean)
+        .join("\n");
+}