@mcoda/mswarm 0.1.57 → 0.1.60

package/dist/vendor/codali/eval/ReportSerializer.js

@@ -0,0 +1,33 @@
+import { stableJsonStringify } from "./SuiteSchema.js";
+const asRecord = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+};
+export const serializeEvalReport = (report, pretty = true) => {
+    const stable = stableJsonStringify(report);
+    if (!pretty)
+        return stable;
+    const parsed = JSON.parse(stable);
+    return `${JSON.stringify(parsed, null, 2)}\n`;
+};
+export const parseEvalReport = (content) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Report JSON parse failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const report = asRecord(parsed);
+    if (!report) {
+        throw new Error("Report payload must be an object.");
+    }
+    if (report.schema_version !== 1) {
+        throw new Error("Unsupported report schema_version.");
+    }
+    if (typeof report.report_id !== "string" || !report.report_id.trim()) {
+        throw new Error("Report report_id is required.");
+    }
+    return report;
+};

package/dist/vendor/codali/eval/ReportStore.d.ts

@@ -0,0 +1,18 @@
+import { type EvalReport } from "./ReportSerializer.js";
+export declare class ReportStore {
+    readonly report_dir: string;
+    constructor(workspaceRoot: string, reportDir?: string);
+    private ensureDir;
+    save(report: EvalReport): Promise<string>;
+    read(reportPath: string): Promise<EvalReport>;
+    resolvePath(reportPath: string, cwd: string): Promise<string>;
+    listReports(): Promise<string[]>;
+    findLatestForSuite(params: {
+        suite_fingerprint: string;
+        exclude_report_id?: string;
+    }): Promise<{
+        path: string;
+        report: EvalReport;
+    } | undefined>;
+}
+//# sourceMappingURL=ReportStore.d.ts.map

package/dist/vendor/codali/eval/ReportStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReportStore.d.ts","sourceRoot":"","sources":["../../src/eval/ReportStore.ts"],"names":[],"mappings":"AAIA,OAAO,EAAwC,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAuC9F,qBAAa,WAAW;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEhB,aAAa,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;YAKvC,SAAS;IAIjB,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAUzC,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAK7C,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7D,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAmBhC,kBAAkB,CAAC,MAAM,EAAE;QAC/B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,GAAG,SAAS,CAAC;CAe9D"}

package/dist/vendor/codali/eval/ReportStore.js

@@ -0,0 +1,96 @@
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getGlobalWorkspaceDir } from "../runtime/StoragePaths.js";
+import { DEFAULT_LOG_DIR } from "../config/Config.js";
+import { parseEvalReport, serializeEvalReport } from "./ReportSerializer.js";
+const sanitize = (value) => value
+    .trim()
+    .replace(/[^a-z0-9._-]+/gi, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .toLowerCase() || "suite";
+const fileTimestamp = (filePath) => {
+    const match = /-(\d{13})-[a-z0-9._-]+\.json$/i.exec(path.basename(filePath));
+    if (!match)
+        return undefined;
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const reportSortKey = async (filePath) => {
+    let mtimeMs = 0;
+    try {
+        const info = await stat(filePath);
+        mtimeMs = info.mtimeMs;
+    }
+    catch {
+        mtimeMs = 0;
+    }
+    return {
+        // Prefer timestamp encoded in the report filename to avoid OS-specific mtime granularity.
+        timestamp: fileTimestamp(filePath) ?? Math.floor(mtimeMs),
+        mtimeMs,
+        fileName: path.basename(filePath).toLowerCase(),
+    };
+};
+export class ReportStore {
+    constructor(workspaceRoot, reportDir) {
+        const storageRoot = getGlobalWorkspaceDir(workspaceRoot);
+        this.report_dir = path.resolve(storageRoot, reportDir ?? path.join(DEFAULT_LOG_DIR, "eval"));
+    }
+    async ensureDir() {
+        await mkdir(this.report_dir, { recursive: true });
+    }
+    async save(report) {
+        await this.ensureDir();
+        const suiteId = sanitize(report.suite.suite_id);
+        const timestamp = Date.now();
+        const fileName = `${suiteId}-${timestamp}-${sanitize(report.report_id)}.json`;
+        const filePath = path.join(this.report_dir, fileName);
+        await writeFile(filePath, serializeEvalReport(report, true), "utf8");
+        return filePath;
+    }
+    async read(reportPath) {
+        const content = await readFile(reportPath, "utf8");
+        return parseEvalReport(content);
+    }
+    async resolvePath(reportPath, cwd) {
+        const candidate = path.isAbsolute(reportPath) ? reportPath : path.resolve(cwd, reportPath);
+        return path.resolve(candidate);
+    }
+    async listReports() {
+        await this.ensureDir();
+        const entries = await readdir(this.report_dir);
+        const jsonEntries = entries
+            .filter((entry) => entry.endsWith(".json"))
+            .map((entry) => path.join(this.report_dir, entry));
+        const withKeys = await Promise.all(jsonEntries.map(async (entry) => ({ entry, key: await reportSortKey(entry) })));
+        withKeys.sort((left, right) => {
+            const byTimestamp = right.key.timestamp - left.key.timestamp;
+            if (byTimestamp !== 0)
+                return byTimestamp;
+            const byMtime = right.key.mtimeMs - left.key.mtimeMs;
+            if (byMtime !== 0)
+                return byMtime;
+            return right.key.fileName.localeCompare(left.key.fileName);
+        });
+        return withKeys.map((entry) => entry.entry);
+    }
+    async findLatestForSuite(params) {
+        const reportFiles = await this.listReports();
+        for (const reportFile of reportFiles) {
+            let parsed;
+            try {
+                parsed = await this.read(reportFile);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.suite.suite_fingerprint !== params.suite_fingerprint)
+                continue;
+            if (params.exclude_report_id && parsed.report_id === params.exclude_report_id)
+                continue;
+            return { path: reportFile, report: parsed };
+        }
+        return undefined;
+    }
+}

package/dist/vendor/codali/eval/SuiteLoader.d.ts

@@ -0,0 +1,12 @@
+import { type EvalSuiteDefinition, type EvalTaskDefinition } from "./SuiteSchema.js";
+export interface LoadedEvalSuite {
+    suite_path: string;
+    suite_dir: string;
+    suite_fingerprint: string;
+    suite: EvalSuiteDefinition;
+}
+export declare const hashSuiteDefinition: (suite: EvalSuiteDefinition) => string;
+export declare const resolveSuitePath: (suitePath: string, cwd: string) => string;
+export declare const resolveTaskFilePath: (task: EvalTaskDefinition, suiteDir: string, workspaceRoot: string) => string | undefined;
+export declare const loadSuiteFromFile: (suitePath: string, cwd?: string) => Promise<LoadedEvalSuite>;
+//# sourceMappingURL=SuiteLoader.d.ts.map

package/dist/vendor/codali/eval/SuiteLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuiteLoader.d.ts","sourceRoot":"","sources":["../../src/eval/SuiteLoader.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,mBAAmB,CAAC;CAC5B;AAgBD,eAAO,MAAM,mBAAmB,GAAI,OAAO,mBAAmB,KAAG,MACc,CAAC;AAEhF,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,EAAE,KAAK,MAAM,KAAG,MAMjE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,MAAM,kBAAkB,EACxB,UAAU,MAAM,EAChB,eAAe,MAAM,KACpB,MAAM,GAAG,SAMX,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,WAAW,MAAM,EACjB,YAAmB,KAClB,OAAO,CAAC,eAAe,CAiCzB,CAAC"}

package/dist/vendor/codali/eval/SuiteLoader.js

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { normalizeSuiteDefinition, stableJsonStringify, SuiteValidationError, } from "./SuiteSchema.js";
+const toSuiteValidationError = (label, message, code, pathLabel = label) => new SuiteValidationError(`${label} validation failed.`, [
+    {
+        path: pathLabel,
+        code,
+        message,
+    },
+]);
+export const hashSuiteDefinition = (suite) => createHash("sha256").update(stableJsonStringify(suite), "utf8").digest("hex");
+export const resolveSuitePath = (suitePath, cwd) => {
+    const trimmed = suitePath.trim();
+    if (!trimmed) {
+        throw toSuiteValidationError("suite", "Suite path must be non-empty.", "missing_suite_path");
+    }
+    return path.resolve(cwd, trimmed);
+};
+export const resolveTaskFilePath = (task, suiteDir, workspaceRoot) => {
+    if (!task.task_file)
+        return undefined;
+    const candidate = path.isAbsolute(task.task_file)
+        ? task.task_file
+        : path.resolve(suiteDir, task.task_file);
+    return path.resolve(workspaceRoot, path.relative(workspaceRoot, candidate));
+};
+export const loadSuiteFromFile = async (suitePath, cwd = process.cwd()) => {
+    const resolvedPath = resolveSuitePath(suitePath, cwd);
+    let content = "";
+    try {
+        content = await readFile(resolvedPath, "utf8");
+    }
+    catch (error) {
+        throw toSuiteValidationError("suite", `Unable to read suite file: ${error instanceof Error ? error.message : String(error)}`, "suite_read_failed", resolvedPath);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(content);
+    }
+    catch (error) {
+        throw toSuiteValidationError("suite", `Suite file is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, "suite_invalid_json", resolvedPath);
+    }
+    const suite = normalizeSuiteDefinition(raw, resolvedPath);
+    return {
+        suite_path: resolvedPath,
+        suite_dir: path.dirname(resolvedPath),
+        suite_fingerprint: hashSuiteDefinition(suite),
+        suite,
+    };
+};

package/dist/vendor/codali/eval/SuiteSchema.d.ts

@@ -0,0 +1,56 @@
+export declare const EVAL_COMMANDS: readonly ["run", "fix", "review", "explain", "test"];
+export type EvalCommandName = (typeof EVAL_COMMANDS)[number];
+export declare const EVAL_VERIFICATION_EXPECTATIONS: readonly ["verified_passed", "verified_failed", "unverified_with_reason", "any"];
+export type EvalVerificationExpectation = (typeof EVAL_VERIFICATION_EXPECTATIONS)[number];
+export interface EvalGateThresholds {
+    patch_apply_drop_max: number;
+    verification_pass_rate_min: number;
+    hallucination_rate_max: number;
+    scope_violation_rate_max: number;
+}
+export interface EvalSuiteBaseline {
+    mode: "previous" | "none";
+    report_path?: string;
+}
+export interface EvalTaskAssertions {
+    expect_success: boolean;
+    expect_exit_code?: number;
+    expect_patch_apply?: boolean;
+    expect_verification?: EvalVerificationExpectation;
+    max_latency_ms?: number;
+    max_cost_usd?: number;
+    allow_hallucination: boolean;
+    allow_scope_violation: boolean;
+}
+export interface EvalTaskDefinition {
+    id: string;
+    title: string;
+    description?: string;
+    mode: "success" | "failure";
+    command: EvalCommandName;
+    task_file?: string;
+    inline_task?: string;
+    args: string[];
+    assertions: EvalTaskAssertions;
+}
+export interface EvalSuiteDefinition {
+    schema_version: 1;
+    suite_id: string;
+    name: string;
+    description?: string;
+    thresholds?: Partial<EvalGateThresholds>;
+    baseline?: EvalSuiteBaseline;
+    tasks: EvalTaskDefinition[];
+}
+export interface SuiteValidationIssue {
+    path: string;
+    code: string;
+    message: string;
+}
+export declare class SuiteValidationError extends Error {
+    readonly issues: SuiteValidationIssue[];
+    constructor(message: string, issues: SuiteValidationIssue[]);
+}
+export declare const normalizeSuiteDefinition: (raw: unknown, label?: string) => EvalSuiteDefinition;
+export declare const stableJsonStringify: (value: unknown) => string;
+//# sourceMappingURL=SuiteSchema.d.ts.map

package/dist/vendor/codali/eval/SuiteSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SuiteSchema.d.ts","sourceRoot":"","sources":["../../src/eval/SuiteSchema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,sDAAuD,CAAC;AAClF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7D,eAAO,MAAM,8BAA8B,kFAKjC,CAAC;AACX,MAAM,MAAM,2BAA2B,GAAG,CAAC,OAAO,8BAA8B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1F,MAAM,WAAW,kBAAkB;IACjC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,0BAA0B,EAAE,MAAM,CAAC;IACnC,sBAAsB,EAAE,MAAM,CAAC;IAC/B,wBAAwB,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,mBAAmB,CAAC,EAAE,2BAA2B,CAAC;IAClD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,qBAAqB,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IAC5B,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,kBAAkB,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,CAAC,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACzC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,KAAK,EAAE,kBAAkB,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC;gBAE5B,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,EAAE;CAK5D;AAsUD,eAAO,MAAM,wBAAwB,GAAI,KAAK,OAAO,EAAE,cAAe,KAAG,mBAyExE,CAAC;AAYF,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,MAClB,CAAC"}

package/dist/vendor/codali/eval/SuiteSchema.js

@@ -0,0 +1,357 @@
+export const EVAL_COMMANDS = ["run", "fix", "review", "explain", "test"];
+export const EVAL_VERIFICATION_EXPECTATIONS = [
+    "verified_passed",
+    "verified_failed",
+    "unverified_with_reason",
+    "any",
+];
+export class SuiteValidationError extends Error {
+    constructor(message, issues) {
+        super(message);
+        this.name = "SuiteValidationError";
+        this.issues = issues;
+    }
+}
+const asRecord = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+};
+const readAliased = (source, aliases) => {
+    for (const alias of aliases) {
+        if (Object.prototype.hasOwnProperty.call(source, alias))
+            return source[alias];
+    }
+    return undefined;
+};
+const readString = (source, aliases) => {
+    const value = readAliased(source, aliases);
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length ? normalized : undefined;
+};
+const readBoolean = (source, aliases) => {
+    const value = readAliased(source, aliases);
+    return typeof value === "boolean" ? value : undefined;
+};
+const readNumber = (source, aliases) => {
+    const value = readAliased(source, aliases);
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+};
+const readInteger = (source, aliases) => {
+    const value = readNumber(source, aliases);
+    return value !== undefined && Number.isInteger(value) ? value : undefined;
+};
+const normalizeRateField = (source, aliases, issues, pathLabel) => {
+    const value = readNumber(source, aliases);
+    if (value === undefined)
+        return undefined;
+    if (value < 0 || value > 1) {
+        issues.push({
+            path: pathLabel,
+            code: "invalid_rate_range",
+            message: "Expected a number between 0 and 1.",
+        });
+        return undefined;
+    }
+    return value;
+};
+const normalizeVerificationExpectation = (source, issues, pathLabel) => {
+    const value = readString(source, ["expect_verification", "expectVerification"]);
+    if (!value)
+        return undefined;
+    if (EVAL_VERIFICATION_EXPECTATIONS.includes(value)) {
+        return value;
+    }
+    if (["verified_passed", "verified_failed", "unverified_with_reason"].includes(value)) {
+        return value;
+    }
+    issues.push({
+        path: pathLabel,
+        code: "invalid_verification_expectation",
+        message: `Expected one of: ${EVAL_VERIFICATION_EXPECTATIONS.join(", ")}.`,
+    });
+    return undefined;
+};
+const normalizeTaskAssertions = (rawValue, taskPath, taskMode, issues) => {
+    const source = asRecord(rawValue) ?? {};
+    if (!asRecord(rawValue) && rawValue !== undefined) {
+        issues.push({
+            path: `${taskPath}.assertions`,
+            code: "invalid_object",
+            message: "Expected an object for assertions.",
+        });
+    }
+    const expectSuccess = readBoolean(source, ["expect_success", "expectSuccess"]) ?? (taskMode !== "failure");
+    const explicitExitCode = readInteger(source, ["expect_exit_code", "expectExitCode"]);
+    const expectExitCode = explicitExitCode ?? (expectSuccess ? 0 : undefined);
+    if (explicitExitCode !== undefined && explicitExitCode < 0) {
+        issues.push({
+            path: `${taskPath}.assertions.expect_exit_code`,
+            code: "invalid_exit_code",
+            message: "Expected a non-negative integer.",
+        });
+    }
+    const maxLatencyMs = readNumber(source, ["max_latency_ms", "maxLatencyMs"]);
+    if (maxLatencyMs !== undefined && maxLatencyMs <= 0) {
+        issues.push({
+            path: `${taskPath}.assertions.max_latency_ms`,
+            code: "invalid_latency",
+            message: "Expected max latency to be greater than 0.",
+        });
+    }
+    const maxCostUsd = readNumber(source, ["max_cost_usd", "maxCostUsd"]);
+    if (maxCostUsd !== undefined && maxCostUsd < 0) {
+        issues.push({
+            path: `${taskPath}.assertions.max_cost_usd`,
+            code: "invalid_cost",
+            message: "Expected max cost to be greater than or equal to 0.",
+        });
+    }
+    return {
+        expect_success: expectSuccess,
+        expect_exit_code: expectExitCode,
+        expect_patch_apply: readBoolean(source, ["expect_patch_apply", "expectPatchApply"]),
+        expect_verification: normalizeVerificationExpectation(source, issues, `${taskPath}.assertions.expect_verification`),
+        max_latency_ms: maxLatencyMs !== undefined && maxLatencyMs > 0 ? maxLatencyMs : undefined,
+        max_cost_usd: maxCostUsd !== undefined && maxCostUsd >= 0 ? maxCostUsd : undefined,
+        allow_hallucination: readBoolean(source, ["allow_hallucination", "allowHallucination"]) ?? false,
+        allow_scope_violation: readBoolean(source, ["allow_scope_violation", "allowScopeViolation"]) ?? false,
+    };
+};
+const normalizeTask = (value, index, issues) => {
+    const taskPath = `tasks[${index}]`;
+    const source = asRecord(value);
+    if (!source) {
+        issues.push({
+            path: taskPath,
+            code: "invalid_object",
+            message: "Expected task to be an object.",
+        });
+    }
+    const taskSource = source ?? {};
+    const id = readString(taskSource, ["id"]) ?? `task-${index + 1}`;
+    if (!readString(taskSource, ["id"])) {
+        issues.push({
+            path: `${taskPath}.id`,
+            code: "missing_required",
+            message: "Task id is required.",
+        });
+    }
+    const title = readString(taskSource, ["title"]) ?? id;
+    const modeValue = readString(taskSource, ["mode"]);
+    const mode = modeValue === "success" || modeValue === "failure"
+        ? modeValue
+        : (readBoolean(asRecord(readAliased(taskSource, ["assertions"])) ?? {}, ["expect_success", "expectSuccess"])
+            === false
+            ? "failure"
+            : "success");
+    if (modeValue && modeValue !== "success" && modeValue !== "failure") {
+        issues.push({
+            path: `${taskPath}.mode`,
+            code: "invalid_mode",
+            message: "Expected task mode to be success|failure.",
+        });
+    }
+    const commandValue = readString(taskSource, ["command"]);
+    const command = commandValue && EVAL_COMMANDS.includes(commandValue)
+        ? commandValue
+        : "run";
+    if (commandValue && !EVAL_COMMANDS.includes(commandValue)) {
+        issues.push({
+            path: `${taskPath}.command`,
+            code: "invalid_command",
+            message: `Expected command to be one of: ${EVAL_COMMANDS.join(", ")}.`,
+        });
+    }
+    const taskFile = readString(taskSource, ["task_file", "taskFile"]);
+    const inlineTask = readString(taskSource, ["inline_task", "inlineTask"]);
+    if (!taskFile && !inlineTask) {
+        issues.push({
+            path: taskPath,
+            code: "missing_task_input",
+            message: "Expected exactly one of task_file or inline_task.",
+        });
+    }
+    if (taskFile && inlineTask) {
+        issues.push({
+            path: taskPath,
+            code: "ambiguous_task_input",
+            message: "Provide only one of task_file or inline_task.",
+        });
+    }
+    const argsValue = readAliased(taskSource, ["args"]);
+    const args = [];
+    if (Array.isArray(argsValue)) {
+        for (let argIndex = 0; argIndex < argsValue.length; argIndex += 1) {
+            const entry = argsValue[argIndex];
+            if (typeof entry !== "string") {
+                issues.push({
+                    path: `${taskPath}.args[${argIndex}]`,
+                    code: "invalid_arg",
+                    message: "Expected every task arg to be a string.",
+                });
+                continue;
+            }
+            const normalized = entry.trim();
+            if (normalized)
+                args.push(normalized);
+        }
+    }
+    else if (argsValue !== undefined) {
+        issues.push({
+            path: `${taskPath}.args`,
+            code: "invalid_args",
+            message: "Expected args to be an array of strings.",
+        });
+    }
+    return {
+        id,
+        title,
+        description: readString(taskSource, ["description"]),
+        mode,
+        command,
+        task_file: taskFile,
+        inline_task: inlineTask,
+        args,
+        assertions: normalizeTaskAssertions(readAliased(taskSource, ["assertions"]), taskPath, mode, issues),
+    };
+};
+const normalizeThresholds = (value, issues) => {
+    if (value === undefined)
+        return undefined;
+    const source = asRecord(value);
+    if (!source) {
+        issues.push({
+            path: "thresholds",
+            code: "invalid_object",
+            message: "Expected thresholds to be an object.",
+        });
+        return undefined;
+    }
+    const thresholds = {};
+    const patchApplyDropMax = normalizeRateField(source, ["patch_apply_drop_max", "patchApplyDropMax"], issues, "thresholds.patch_apply_drop_max");
+    if (patchApplyDropMax !== undefined)
+        thresholds.patch_apply_drop_max = patchApplyDropMax;
+    const verificationPassRateMin = normalizeRateField(source, ["verification_pass_rate_min", "verificationPassRateMin"], issues, "thresholds.verification_pass_rate_min");
+    if (verificationPassRateMin !== undefined) {
+        thresholds.verification_pass_rate_min = verificationPassRateMin;
+    }
+    const hallucinationRateMax = normalizeRateField(source, ["hallucination_rate_max", "hallucinationRateMax"], issues, "thresholds.hallucination_rate_max");
+    if (hallucinationRateMax !== undefined)
+        thresholds.hallucination_rate_max = hallucinationRateMax;
+    const scopeViolationRateMax = normalizeRateField(source, ["scope_violation_rate_max", "scopeViolationRateMax"], issues, "thresholds.scope_violation_rate_max");
+    if (scopeViolationRateMax !== undefined) {
+        thresholds.scope_violation_rate_max = scopeViolationRateMax;
+    }
+    return Object.keys(thresholds).length ? thresholds : undefined;
+};
+const normalizeBaseline = (value, issues) => {
+    if (value === undefined)
+        return undefined;
+    const source = asRecord(value);
+    if (!source) {
+        issues.push({
+            path: "baseline",
+            code: "invalid_object",
+            message: "Expected baseline to be an object.",
+        });
+        return undefined;
+    }
+    const modeValue = readString(source, ["mode"]);
+    let mode = "previous";
+    if (modeValue === "previous" || modeValue === "none") {
+        mode = modeValue;
+    }
+    else if (modeValue) {
+        issues.push({
+            path: "baseline.mode",
+            code: "invalid_baseline_mode",
+            message: "Expected baseline.mode to be previous|none.",
+        });
+    }
+    return {
+        mode,
+        report_path: readString(source, ["report_path", "reportPath"]),
+    };
+};
+export const normalizeSuiteDefinition = (raw, label = "suite") => {
+    const issues = [];
+    const source = asRecord(raw);
+    if (!source) {
+        throw new SuiteValidationError(`${label} is invalid.`, [
+            {
+                path: label,
+                code: "invalid_object",
+                message: "Expected suite root to be an object.",
+            },
+        ]);
+    }
+    const schemaVersion = readInteger(source, ["schema_version", "schemaVersion"]) ?? 1;
+    if (schemaVersion !== 1) {
+        issues.push({
+            path: "schema_version",
+            code: "unsupported_schema_version",
+            message: "Only schema_version=1 is supported.",
+        });
+    }
+    const suiteId = readString(source, ["suite_id", "suiteId"]);
+    if (!suiteId) {
+        issues.push({
+            path: "suite_id",
+            code: "missing_required",
+            message: "suite_id is required.",
+        });
+    }
+    const tasksValue = readAliased(source, ["tasks"]);
+    if (!Array.isArray(tasksValue) || tasksValue.length === 0) {
+        issues.push({
+            path: "tasks",
+            code: "missing_tasks",
+            message: "tasks must be a non-empty array.",
+        });
+    }
+    const tasksRaw = Array.isArray(tasksValue) ? tasksValue : [];
+    const tasks = tasksRaw.map((entry, index) => normalizeTask(entry, index, issues));
+    const seenTaskIds = new Set();
+    for (const task of tasks) {
+        if (seenTaskIds.has(task.id)) {
+            issues.push({
+                path: `tasks.${task.id}`,
+                code: "duplicate_task_id",
+                message: `Task id "${task.id}" is duplicated.`,
+            });
+            continue;
+        }
+        seenTaskIds.add(task.id);
+    }
+    if (issues.length > 0) {
+        throw new SuiteValidationError(`${label} validation failed.`, issues);
+    }
+    const normalized = {
+        schema_version: 1,
+        suite_id: suiteId ?? "unknown-suite",
+        name: readString(source, ["name"]) ?? (suiteId ?? "unnamed-suite"),
+        description: readString(source, ["description"]),
+        thresholds: normalizeThresholds(readAliased(source, ["thresholds"]), issues),
+        baseline: normalizeBaseline(readAliased(source, ["baseline"]), issues),
+        tasks,
+    };
+    if (issues.length > 0) {
+        throw new SuiteValidationError(`${label} validation failed.`, issues);
+    }
+    return normalized;
+};
+const stableSort = (value) => {
+    if (Array.isArray(value))
+        return value.map(stableSort);
+    if (!value || typeof value !== "object")
+        return value;
+    const source = value;
+    const sortedEntries = Object.keys(source)
+        .sort((left, right) => left.localeCompare(right))
+        .map((key) => [key, stableSort(source[key])]);
+    return Object.fromEntries(sortedEntries);
+};
+export const stableJsonStringify = (value) => JSON.stringify(stableSort(value));

package/dist/vendor/codali/index.d.ts

@@ -0,0 +1,11 @@
+export { runCli } from "./cli.js";
+export { codaliEventToOpenAIChatCompletionChunk, codaliEventToOpenAISseData, createCodaliRuntime, runCodaliTask, } from "./runtime/CodaliRuntime.js";
+export { loadInstructionBlocks, formatInstructionBlocks } from "./session/InstructionLoader.js";
+export { SessionStore } from "./session/SessionStore.js";
+export { SubagentOrchestrator } from "./subagents/SubagentOrchestrator.js";
+export type { ProviderMessage, ProviderUsage, } from "./providers/ProviderTypes.js";
+export type { CodaliRuntime, CodaliOpenAIChunkOptions, CodaliRuntimeAgentInput, CodaliRuntimeDocdexInput, CodaliRuntimeEvent, CodaliRuntimeInput, CodaliRuntimePolicy, CodaliRuntimeProviderInput, CodaliRuntimeSessionInput, CodaliRuntimeSubagentsInput, CodaliRuntimeResult, CodaliRuntimeWorkspace, } from "./runtime/CodaliRuntime.js";
+export type { InstructionBlock, InstructionLoadOptions, } from "./session/InstructionLoader.js";
+export type { CodaliResumeBundle, CodaliSessionMetadata, CodaliSessionStatus, CodaliSessionSummary, CodaliSessionTranscriptEvent, } from "./session/SessionStore.js";
+export type { SubagentPermissions, SubagentResult, SubagentRole, SubagentSpec, SubagentStatus, } from "./subagents/SubagentOrchestrator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/vendor/codali/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EACL,sCAAsC,EACtC,0BAA0B,EAC1B,mBAAmB,EACnB,aAAa,GACd,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAChG,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,YAAY,EACV,eAAe,EACf,aAAa,GACd,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,aAAa,EACb,wBAAwB,EACxB,uBAAuB,EACvB,wBAAwB,EACxB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC3B,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EACV,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,gCAAgC,CAAC;AACxC,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,cAAc,GACf,MAAM,qCAAqC,CAAC"}

package/dist/vendor/codali/index.js

@@ -0,0 +1,5 @@
+export { runCli } from "./cli.js";
+export { codaliEventToOpenAIChatCompletionChunk, codaliEventToOpenAISseData, createCodaliRuntime, runCodaliTask, } from "./runtime/CodaliRuntime.js";
+export { loadInstructionBlocks, formatInstructionBlocks } from "./session/InstructionLoader.js";
+export { SessionStore } from "./session/SessionStore.js";
+export { SubagentOrchestrator } from "./subagents/SubagentOrchestrator.js";

package/dist/vendor/codali/providers/CodexCliProvider.d.ts

@@ -0,0 +1,8 @@
+import type { Provider, ProviderConfig, ProviderRequest, ProviderResponse } from "./ProviderTypes.js";
+export declare class CodexCliProvider implements Provider {
+    private config;
+    name: string;
+    constructor(config: ProviderConfig);
+    generate(request: ProviderRequest): Promise<ProviderResponse>;
+}
+//# sourceMappingURL=CodexCliProvider.d.ts.map