@mcoda/mswarm 0.1.56 → 0.1.60

package/dist/vendor/codali/runtime/DeepInvestigationErrors.d.ts

@@ -0,0 +1,39 @@
+import type { DeepInvestigationToolQuotaConfig } from "../config/Config.js";
+import type { EvidenceGateMetrics } from "../cognitive/Types.js";
+export type DeepInvestigationErrorCode = "deep_investigation_docdex_unavailable" | "deep_investigation_quota_unmet" | "deep_investigation_budget_unmet" | "deep_investigation_evidence_unmet";
+export type DeepInvestigationErrorDetails = Record<string, unknown>;
+type DeepInvestigationErrorInput = {
+    code: DeepInvestigationErrorCode;
+    message: string;
+    remediation: string[];
+    details?: DeepInvestigationErrorDetails;
+    name?: string;
+};
+export declare class DeepInvestigationError extends Error {
+    readonly code: DeepInvestigationErrorCode;
+    readonly remediation: string[];
+    readonly details?: DeepInvestigationErrorDetails;
+    constructor({ code, message, remediation, details, name }: DeepInvestigationErrorInput);
+}
+export declare const createDeepInvestigationDocdexError: (missing: string[], remediation: string[]) => DeepInvestigationError;
+export declare const createDeepInvestigationQuotaError: (input: {
+    missing: string[];
+    required: DeepInvestigationToolQuotaConfig;
+    observed: DeepInvestigationToolQuotaConfig;
+}) => DeepInvestigationError;
+export declare const createDeepInvestigationBudgetError: (input: {
+    minCycles: number;
+    minSeconds: number;
+    maxCycles: number;
+    cycles: number;
+    elapsedMs: number;
+}) => DeepInvestigationError;
+export declare const createDeepInvestigationEvidenceError: (input: {
+    missing: string[];
+    required: EvidenceGateMetrics | Record<string, number>;
+    observed: EvidenceGateMetrics | Record<string, number>;
+    warnings: string[];
+    gaps: string[];
+}) => DeepInvestigationError;
+export {};
+//# sourceMappingURL=DeepInvestigationErrors.d.ts.map

package/dist/vendor/codali/runtime/DeepInvestigationErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepInvestigationErrors.d.ts","sourceRoot":"","sources":["../../src/runtime/DeepInvestigationErrors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAC5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,MAAM,MAAM,0BAA0B,GAClC,uCAAuC,GACvC,gCAAgC,GAChC,iCAAiC,GACjC,mCAAmC,CAAC;AAExC,MAAM,MAAM,6BAA6B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpE,KAAK,2BAA2B,GAAG;IACjC,IAAI,EAAE,0BAA0B,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,CAAC,EAAE,6BAA6B,CAAC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,6BAA6B,CAAC;gBAErC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,2BAA2B;CAOvF;AAED,eAAO,MAAM,kCAAkC,GAC7C,SAAS,MAAM,EAAE,EACjB,aAAa,MAAM,EAAE,KACpB,sBAaF,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAAI,OAAO;IACvD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,gCAAgC,CAAC;IAC3C,QAAQ,EAAE,gCAAgC,CAAC;CAC5C,KAAG,sBAeH,CAAC;AAEF,eAAO,MAAM,kCAAkC,GAAI,OAAO;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,KAAG,sBAUA,CAAC;AAEL,eAAO,MAAM,oCAAoC,GAAI,OAAO;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvD,QAAQ,EAAE,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,KAAG,sBAUA,CAAC"}

package/dist/vendor/codali/runtime/DeepInvestigationErrors.js

@@ -0,0 +1,57 @@
+export class DeepInvestigationError extends Error {
+    constructor({ code, message, remediation, details, name }) {
+        super(message);
+        this.name = name ?? "DeepInvestigationError";
+        this.code = code;
+        this.remediation = remediation;
+        this.details = details;
+    }
+}
+export const createDeepInvestigationDocdexError = (missing, remediation) => {
+    const message = [
+        "Deep investigation requires docdex health, stats, and file coverage.",
+        `Missing: ${missing.join(", ")}`,
+        `Remediation: ${remediation.join(" | ")}`,
+    ].join(" ");
+    return new DeepInvestigationError({
+        code: "deep_investigation_docdex_unavailable",
+        message,
+        remediation,
+        details: { missing },
+        name: "DeepInvestigationDocdexError",
+    });
+};
+export const createDeepInvestigationQuotaError = (input) => {
+    const missingList = input.missing.join(", ");
+    return new DeepInvestigationError({
+        code: "deep_investigation_quota_unmet",
+        message: `Deep investigation tool quota unmet. Missing categories: ${missingList}`,
+        remediation: [
+            "Increase deepInvestigation.toolQuota requirements.",
+            "Ensure the research phase executes the required docdex tools.",
+        ],
+        details: {
+            missing: input.missing,
+            required: input.required,
+            observed: input.observed,
+        },
+    });
+};
+export const createDeepInvestigationBudgetError = (input) => new DeepInvestigationError({
+    code: "deep_investigation_budget_unmet",
+    message: "Deep investigation budget unmet. Increase min cycles/time or reduce requirements.",
+    remediation: [
+        "Increase deepInvestigation.investigationBudget minCycles/minSeconds.",
+        "Reduce research requirements if budget is intentionally smaller.",
+    ],
+    details: { ...input },
+});
+export const createDeepInvestigationEvidenceError = (input) => new DeepInvestigationError({
+    code: "deep_investigation_evidence_unmet",
+    message: "Deep investigation evidence gate unmet. Increase research depth or relax evidence thresholds.",
+    remediation: [
+        "Increase research depth or add more docdex tool coverage.",
+        "Relax deepInvestigation.evidenceGate thresholds if necessary.",
+    ],
+    details: { ...input },
+});

package/dist/vendor/codali/runtime/RunContext.d.ts

@@ -0,0 +1,27 @@
+import type { RunContractFingerprint } from "../cognitive/Types.js";
+export interface RunFingerprintInput {
+    request: string;
+    command?: string;
+    workspaceRoot: string;
+    smart?: boolean;
+    provider?: string;
+    model?: string;
+    builderMode?: string;
+    maxRetries?: number;
+    maxContextRefreshes?: number;
+    maxSteps?: number;
+    maxToolCalls?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+}
+export declare class RunContext {
+    readonly runId: string;
+    readonly workspaceRoot: string;
+    readonly startedAt: number;
+    readonly fingerprint?: RunContractFingerprint;
+    private touchedFiles;
+    constructor(runId: string, workspaceRoot: string, fingerprintInput?: RunFingerprintInput);
+    recordTouchedFile(filePath: string): void;
+    getTouchedFiles(): string[];
+}
+//# sourceMappingURL=RunContext.d.ts.map

package/dist/vendor/codali/runtime/RunContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunContext.d.ts","sourceRoot":"","sources":["../../src/runtime/RunContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAsCD,qBAAa,UAAU;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,sBAAsB,CAAC;IAC9C,OAAO,CAAC,YAAY,CAAqB;gBAE7B,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,mBAAmB;IAOxF,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIzC,eAAe,IAAI,MAAM,EAAE;CAG5B"}

package/dist/vendor/codali/runtime/RunContext.js

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+const stableSort = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((entry) => stableSort(entry));
+    }
+    if (!value || typeof value !== "object")
+        return value;
+    const entries = Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => [key, stableSort(entry)]);
+    return Object.fromEntries(entries);
+};
+const buildFingerprint = (input) => {
+    const normalized = stableSort({
+        request: input.request,
+        command: input.command ?? "",
+        workspaceRoot: input.workspaceRoot,
+        smart: input.smart ?? false,
+        provider: input.provider ?? "",
+        model: input.model ?? "",
+        builderMode: input.builderMode ?? "",
+        maxRetries: input.maxRetries ?? null,
+        maxContextRefreshes: input.maxContextRefreshes ?? null,
+        maxSteps: input.maxSteps ?? null,
+        maxToolCalls: input.maxToolCalls ?? null,
+        maxTokens: input.maxTokens ?? null,
+        timeoutMs: input.timeoutMs ?? null,
+    });
+    const digest = createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex");
+    return {
+        algorithm: "sha256",
+        value: digest,
+    };
+};
+export class RunContext {
+    constructor(runId, workspaceRoot, fingerprintInput) {
+        this.touchedFiles = new Set();
+        this.runId = runId;
+        this.workspaceRoot = workspaceRoot;
+        this.startedAt = Date.now();
+        this.fingerprint = fingerprintInput ? buildFingerprint(fingerprintInput) : undefined;
+    }
+    recordTouchedFile(filePath) {
+        this.touchedFiles.add(filePath);
+    }
+    getTouchedFiles() {
+        return Array.from(this.touchedFiles).sort();
+    }
+}

package/dist/vendor/codali/runtime/RunLogQuery.d.ts

@@ -0,0 +1,48 @@
+import type { RunFailureClass } from "./RunTelemetryTypes.js";
+export declare const RUN_LOG_QUERY_SCHEMA_VERSION: 1;
+export declare const DEFAULT_RUN_LOG_QUERY_LIMIT = 100;
+export declare const MAX_RUN_LOG_QUERY_LIMIT = 2000;
+export type RunLogQuerySort = "asc" | "desc";
+export interface RunLogQueryFilters {
+    run_id?: string;
+    task_id?: string;
+    phase?: string;
+    event_type?: string;
+    failure_class?: RunFailureClass | string;
+}
+export interface RunLogQueryInput {
+    schema_version?: number;
+    filters?: RunLogQueryFilters;
+    limit?: number;
+    offset?: number;
+    sort?: RunLogQuerySort;
+}
+export interface RunLogQueryEvent {
+    event_index: number;
+    file: string;
+    line: number;
+    type: string;
+    timestamp: string;
+    run_id?: string;
+    task_id?: string;
+    phase?: string;
+    failure_class?: string;
+    data: Record<string, unknown>;
+}
+export interface NormalizedRunLogQuery {
+    schema_version: typeof RUN_LOG_QUERY_SCHEMA_VERSION;
+    filters: RunLogQueryFilters;
+    limit: number;
+    offset: number;
+    sort: RunLogQuerySort;
+}
+export interface RunLogQueryResult {
+    schema_version: typeof RUN_LOG_QUERY_SCHEMA_VERSION;
+    query: NormalizedRunLogQuery;
+    total: number;
+    returned: number;
+    next_offset: number | null;
+    events: RunLogQueryEvent[];
+}
+export declare const normalizeRunLogQueryInput: (input?: RunLogQueryInput) => NormalizedRunLogQuery;
+//# sourceMappingURL=RunLogQuery.d.ts.map

package/dist/vendor/codali/runtime/RunLogQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunLogQuery.d.ts","sourceRoot":"","sources":["../../src/runtime/RunLogQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,eAAO,MAAM,4BAA4B,EAAG,CAAU,CAAC;AACvD,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC;CAC1C;AAED,MAAM,WAAW,gBAAgB;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,eAAe,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,OAAO,4BAA4B,CAAC;IACpD,OAAO,EAAE,kBAAkB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,eAAe,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,OAAO,4BAA4B,CAAC;IACpD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B;AAcD,eAAO,MAAM,yBAAyB,GAAI,QAAO,gBAAqB,KAAG,qBAmBxE,CAAC"}

package/dist/vendor/codali/runtime/RunLogQuery.js

@@ -0,0 +1,36 @@
+export const RUN_LOG_QUERY_SCHEMA_VERSION = 1;
+export const DEFAULT_RUN_LOG_QUERY_LIMIT = 100;
+export const MAX_RUN_LOG_QUERY_LIMIT = 2000;
+const normalizeString = (value) => {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+const normalizeNonNegativeInteger = (value, fallback) => {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    if (value < 0)
+        return fallback;
+    return Math.floor(value);
+};
+export const normalizeRunLogQueryInput = (input = {}) => {
+    const filters = input.filters ?? {};
+    const limitRaw = normalizeNonNegativeInteger(input.limit, DEFAULT_RUN_LOG_QUERY_LIMIT);
+    const limit = Math.min(Math.max(limitRaw, 1), MAX_RUN_LOG_QUERY_LIMIT);
+    const offset = normalizeNonNegativeInteger(input.offset, 0);
+    const sort = input.sort === "desc" ? "desc" : "asc";
+    return {
+        schema_version: RUN_LOG_QUERY_SCHEMA_VERSION,
+        filters: {
+            run_id: normalizeString(filters.run_id),
+            task_id: normalizeString(filters.task_id),
+            phase: normalizeString(filters.phase),
+            event_type: normalizeString(filters.event_type),
+            failure_class: normalizeString(filters.failure_class),
+        },
+        limit,
+        offset,
+        sort,
+    };
+};

package/dist/vendor/codali/runtime/RunLogReader.d.ts

@@ -0,0 +1,19 @@
+import { type RunLogQueryInput, type RunLogQueryResult } from "./RunLogQuery.js";
+import { type SafetyTelemetryEventData } from "./RunTelemetryTypes.js";
+import type { PhaseArtifactV1, VerificationReport } from "../cognitive/Types.js";
+export declare class RunLogReader {
+    private logDir;
+    constructor(workspaceRoot: string, logDirName?: string);
+    private resolveLogFiles;
+    queryEvents(input?: RunLogQueryInput): Promise<RunLogQueryResult>;
+    findLastRunForFile(filePath: string): Promise<string | undefined>;
+    getRunArtifact(runId: string, kind: string): Promise<string | undefined>;
+    getRunIntent(runId: string): Promise<string | undefined>;
+    getPhaseArtifacts(runId: string, phase?: string): Promise<PhaseArtifactV1[]>;
+    getSafetyEvents(runId: string, filters?: {
+        code?: string;
+        phase?: string;
+    }): Promise<SafetyTelemetryEventData[]>;
+    getVerificationReports(runId: string): Promise<VerificationReport[]>;
+}
+//# sourceMappingURL=RunLogReader.d.ts.map

package/dist/vendor/codali/runtime/RunLogReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunLogReader.d.ts","sourceRoot":"","sources":["../../src/runtime/RunLogReader.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAyB,KAAK,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAC9F,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAwEjF,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAS;gBAEX,aAAa,EAAE,MAAM,EAAE,UAAU,SAAS;YAKxC,eAAe;IAqBvB,WAAW,CAAC,KAAK,GAAE,gBAAqB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA+ErE,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAuCjE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAiBxE,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAsCxD,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAsB5E,eAAe,CACnB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,GAC9C,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAwBhC,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;CA8D3E"}

package/dist/vendor/codali/runtime/RunLogReader.js

@@ -0,0 +1,361 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { getGlobalWorkspaceDir } from "./StoragePaths.js";
+import { normalizeRunLogQueryInput, RUN_LOG_QUERY_SCHEMA_VERSION, } from "./RunLogQuery.js";
+import { normalizeFailureClass } from "./RunTelemetryTypes.js";
+const parseJsonSafe = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+};
+const normalizeCandidatePath = (value) => path.normalize(value).replace(/\\/g, "/");
+const asRecord = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+};
+const asString = (value) => {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+const asStringArray = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+};
+const inferRunIdFromEvent = (data, fallbackRunId) => asString(data.run_id) ?? asString(data.runId) ?? fallbackRunId;
+const inferTaskIdFromEvent = (data) => asString(data.task_id) ?? asString(data.taskId);
+const inferPhaseFromEvent = (data) => {
+    const direct = asString(data.phase);
+    if (direct)
+        return direct;
+    const disposition = asRecord(data.final_disposition);
+    const dispositionStage = asString(disposition?.stage);
+    if (dispositionStage)
+        return dispositionStage;
+    const telemetry = asRecord(data.phase_telemetry);
+    return asString(telemetry?.phase);
+};
+const inferFailureClassFromEvent = (data) => {
+    const direct = normalizeFailureClass(data.failure_class ?? data.failureClass);
+    if (direct)
+        return direct;
+    const finalDisposition = asRecord(data.final_disposition);
+    const fromDisposition = normalizeFailureClass(finalDisposition?.failure_class ?? finalDisposition?.failureClass);
+    if (fromDisposition)
+        return fromDisposition;
+    const reasonCodes = asStringArray(data.reason_codes ?? data.reasons);
+    if (reasonCodes.some((reason) => reason.includes("verification")))
+        return "verification_failure";
+    if (reasonCodes.some((reason) => reason.includes("policy") || reason.includes("guardrail"))) {
+        return "policy_failure";
+    }
+    if (reasonCodes.some((reason) => reason.includes("patch")))
+        return "patch_failure";
+    if (reasonCodes.some((reason) => reason.includes("provider")))
+        return "provider_failure";
+    return undefined;
+};
+export class RunLogReader {
+    constructor(workspaceRoot, logDirName = "logs") {
+        const storageRoot = getGlobalWorkspaceDir(workspaceRoot);
+        this.logDir = path.resolve(storageRoot, logDirName);
+    }
+    async resolveLogFiles(runId) {
+        if (runId) {
+            const file = path.join(this.logDir, `${runId}.jsonl`);
+            try {
+                await fs.access(file);
+                return [file];
+            }
+            catch {
+                return [];
+            }
+        }
+        try {
+            const files = await fs.readdir(this.logDir);
+            return files
+                .filter((entry) => entry.endsWith(".jsonl"))
+                .sort((left, right) => left.localeCompare(right))
+                .map((entry) => path.join(this.logDir, entry));
+        }
+        catch {
+            return [];
+        }
+    }
+    async queryEvents(input = {}) {
+        const query = normalizeRunLogQueryInput(input);
+        const files = await this.resolveLogFiles(query.filters.run_id);
+        const matches = [];
+        let eventIndex = 0;
+        for (const filePath of files) {
+            const fallbackRunId = path.basename(filePath, ".jsonl");
+            let content = "";
+            try {
+                content = await fs.readFile(filePath, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const lines = content.split("\n");
+            for (let lineNumber = 0; lineNumber < lines.length; lineNumber += 1) {
+                const line = lines[lineNumber];
+                if (!line.trim())
+                    continue;
+                const parsed = parseJsonSafe(line);
+                const event = asRecord(parsed);
+                if (!event)
+                    continue;
+                const type = asString(event.type);
+                if (!type)
+                    continue;
+                const data = asRecord(event.data) ?? {};
+                const timestamp = asString(event.timestamp) ?? "";
+                const runId = inferRunIdFromEvent(data, fallbackRunId);
+                const taskId = inferTaskIdFromEvent(data);
+                const phase = inferPhaseFromEvent(data);
+                const failureClass = inferFailureClassFromEvent(data);
+                if (query.filters.event_type && type !== query.filters.event_type)
+                    continue;
+                if (query.filters.run_id && runId !== query.filters.run_id)
+                    continue;
+                if (query.filters.task_id && taskId !== query.filters.task_id)
+                    continue;
+                if (query.filters.phase && phase !== query.filters.phase)
+                    continue;
+                if (query.filters.failure_class && failureClass !== query.filters.failure_class)
+                    continue;
+                matches.push({
+                    event_index: eventIndex,
+                    file: filePath,
+                    line: lineNumber + 1,
+                    type,
+                    timestamp,
+                    run_id: runId,
+                    task_id: taskId,
+                    phase,
+                    failure_class: failureClass,
+                    data,
+                });
+                eventIndex += 1;
+            }
+        }
+        const compare = (left, right) => {
+            const byTimestamp = left.timestamp.localeCompare(right.timestamp);
+            if (byTimestamp !== 0)
+                return byTimestamp;
+            const byRun = (left.run_id ?? "").localeCompare(right.run_id ?? "");
+            if (byRun !== 0)
+                return byRun;
+            const byFile = left.file.localeCompare(right.file);
+            if (byFile !== 0)
+                return byFile;
+            const byLine = left.line - right.line;
+            if (byLine !== 0)
+                return byLine;
+            return left.event_index - right.event_index;
+        };
+        matches.sort((left, right) => (query.sort === "asc" ? compare(left, right) : compare(right, left)));
+        const total = matches.length;
+        const events = matches.slice(query.offset, query.offset + query.limit);
+        const nextOffset = query.offset + events.length;
+        return {
+            schema_version: RUN_LOG_QUERY_SCHEMA_VERSION,
+            query,
+            total,
+            returned: events.length,
+            next_offset: nextOffset >= total ? null : nextOffset,
+            events,
+        };
+    }
+    async findLastRunForFile(filePath) {
+        try {
+            const files = await fs.readdir(this.logDir);
+            const jsonlFiles = files.filter((entry) => entry.endsWith(".jsonl"));
+            const sortedFiles = await Promise.all(jsonlFiles.map(async (entry) => {
+                const stat = await fs.stat(path.join(this.logDir, entry));
+                return { file: entry, mtime: stat.mtimeMs };
+            }));
+            sortedFiles.sort((left, right) => right.mtime - left.mtime);
+            for (const { file } of sortedFiles) {
+                const content = await fs.readFile(path.join(this.logDir, file), "utf8");
+                const lines = content.split("\n").filter(Boolean);
+                for (const line of lines) {
+                    const event = parseJsonSafe(line);
+                    if (!event || event.type !== "run_summary")
+                        continue;
+                    const touched = event.data?.touchedFiles ?? [];
+                    const normalizedTarget = normalizeCandidatePath(filePath);
+                    const hit = touched.find((entry) => {
+                        const normalizedTouched = normalizeCandidatePath(entry);
+                        return (normalizedTouched.endsWith(normalizedTarget)
+                            || normalizedTarget.endsWith(normalizedTouched));
+                    });
+                    if (hit)
+                        return event.data?.run_id ?? event.data?.runId;
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        return undefined;
+    }
+    async getRunArtifact(runId, kind) {
+        const phaseDir = path.join(this.logDir, "phase");
+        try {
+            const files = await fs.readdir(phaseDir);
+            const candidates = files.filter((entry) => entry.startsWith(runId) && entry.includes(kind));
+            if (candidates.length === 0)
+                return undefined;
+            const last = candidates.sort().pop();
+            if (last) {
+                return fs.readFile(path.join(phaseDir, last), "utf8");
+            }
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+    async getRunIntent(runId) {
+        const logFile = path.join(this.logDir, `${runId}.jsonl`);
+        try {
+            const content = await fs.readFile(logFile, "utf8");
+            const lines = content.split("\n").filter(Boolean);
+            for (const line of lines) {
+                const event = parseJsonSafe(line);
+                if (!event)
+                    continue;
+                if (event.type === "phase_input" && event.data?.phase === "librarian") {
+                    const artifactPath = event.data.path;
+                    if (artifactPath && typeof artifactPath === "string") {
+                        try {
+                            const artifact = parseJsonSafe(await fs.readFile(artifactPath, "utf8"));
+                            if (!artifact)
+                                continue;
+                            if (typeof artifact.request === "string") {
+                                return artifact.request;
+                            }
+                            const payloadRequest = artifact.payload;
+                            if (typeof payloadRequest?.request === "string")
+                                return payloadRequest.request;
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        return undefined;
+    }
+    async getPhaseArtifacts(runId, phase) {
+        const phaseDir = path.join(this.logDir, "phase");
+        try {
+            const files = await fs.readdir(phaseDir);
+            const artifacts = [];
+            for (const file of files) {
+                if (!file.startsWith(`${runId}-`))
+                    continue;
+                const parsed = parseJsonSafe(await fs.readFile(path.join(phaseDir, file), "utf8"));
+                if (!parsed || parsed.schema_version !== 1)
+                    continue;
+                if (phase && parsed.phase !== phase)
+                    continue;
+                artifacts.push(parsed);
+            }
+            return artifacts.sort((left, right) => (left.ended_at_ms ?? 0) - (right.ended_at_ms ?? 0));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getSafetyEvents(runId, filters = {}) {
+        const logFile = path.join(this.logDir, `${runId}.jsonl`);
+        try {
+            const content = await fs.readFile(logFile, "utf8");
+            const lines = content.split("\n").filter(Boolean);
+            const events = [];
+            for (const line of lines) {
+                const parsed = parseJsonSafe(line);
+                if (!parsed || parsed.type !== "safety_event" || !parsed.data)
+                    continue;
+                const data = parsed.data;
+                if (data.schema_version !== 1)
+                    continue;
+                if (data.run_id !== runId)
+                    continue;
+                if (filters.code && data.code !== filters.code)
+                    continue;
+                if (filters.phase && data.phase !== filters.phase)
+                    continue;
+                events.push(data);
+            }
+            return events;
+        }
+        catch {
+            return [];
+        }
+    }
+    async getVerificationReports(runId) {
+        const reports = [];
+        const seen = new Set();
+        const addReport = (candidate) => {
+            if (!candidate || typeof candidate !== "object")
+                return;
+            const value = candidate;
+            if (value.schema_version !== 1)
+                return;
+            if (value.outcome !== "verified_passed"
+                && value.outcome !== "verified_failed"
+                && value.outcome !== "unverified_with_reason") {
+                return;
+            }
+            const key = JSON.stringify(value);
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            reports.push(value);
+        };
+        const artifacts = await this.getPhaseArtifacts(runId, "verify");
+        for (const artifact of artifacts) {
+            if (artifact.kind === "verification_report") {
+                addReport(artifact.payload);
+            }
+        }
+        const logFile = path.join(this.logDir, `${runId}.jsonl`);
+        try {
+            const content = await fs.readFile(logFile, "utf8");
+            const lines = content.split("\n").filter(Boolean);
+            for (const line of lines) {
+                const parsed = parseJsonSafe(line);
+                if (!parsed || !parsed.data)
+                    continue;
+                if (parsed.type === "verification_report"
+                    && (parsed.data.run_id === runId || parsed.data.runId === runId)) {
+                    addReport(parsed.data.report);
+                }
+                if (parsed.type === "run_summary") {
+                    addReport(parsed.data.verification);
+                    addReport(parsed.data.smartRuntime?.verification);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        return reports;
+    }
+}