@mcoda/mswarm 0.1.57 → 0.1.60

package/dist/vendor/codali/cognitive/ContextStore.d.ts

@@ -0,0 +1,27 @@
+import type { ProviderMessage } from "../providers/ProviderTypes.js";
+export interface ContextMessageRecord extends ProviderMessage {
+    ts: number;
+    model?: string;
+    tokens?: number;
+}
+export interface ContextLaneSnapshot {
+    laneId: string;
+    messages: ContextMessageRecord[];
+    messageCount: number;
+    byteSize: number;
+    updatedAt: number;
+}
+export interface ContextStoreOptions {
+    workspaceRoot: string;
+    storageDir: string;
+}
+export declare class ContextStore {
+    private options;
+    constructor(options: ContextStoreOptions);
+    private lanePath;
+    loadLane(laneId: string): Promise<ContextLaneSnapshot>;
+    append(laneId: string, messages: ContextMessageRecord[] | ContextMessageRecord): Promise<ContextLaneSnapshot>;
+    replace(laneId: string, messages: ContextMessageRecord[]): Promise<ContextLaneSnapshot>;
+    truncate(laneId: string, maxMessages: number): Promise<ContextLaneSnapshot>;
+}
+//# sourceMappingURL=ContextStore.d.ts.map

package/dist/vendor/codali/cognitive/ContextStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextStore.d.ts","sourceRoot":"","sources":["../../src/cognitive/ContextStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAC3D,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,oBAAoB,EAAE,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAqCD,qBAAa,YAAY;IACX,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,mBAAmB;IAEhD,OAAO,CAAC,QAAQ;IAIV,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IActD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,EAAE,GAAG,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAW7G,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAQvF,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAWlF"}

package/dist/vendor/codali/cognitive/ContextStore.js

@@ -0,0 +1,79 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const safeLaneId = (laneId) => laneId.replace(/[^a-zA-Z0-9._-]+/g, "_");
+const resolveLanePath = (workspaceRoot, storageDir, laneId) => {
+    const resolvedDir = path.resolve(workspaceRoot, storageDir);
+    const fileName = `${safeLaneId(laneId)}.jsonl`;
+    const resolvedPath = path.join(resolvedDir, fileName);
+    const relative = path.relative(workspaceRoot, resolvedPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("Path is outside workspace root");
+    }
+    return resolvedPath;
+};
+const parseJsonLines = (content) => {
+    if (!content.trim())
+        return [];
+    return content
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+};
+const buildSnapshot = (laneId, messages, byteSize, updatedAt) => ({
+    laneId,
+    messages,
+    messageCount: messages.length,
+    byteSize,
+    updatedAt,
+});
+export class ContextStore {
+    constructor(options) {
+        this.options = options;
+    }
+    lanePath(laneId) {
+        return resolveLanePath(this.options.workspaceRoot, this.options.storageDir, laneId);
+    }
+    async loadLane(laneId) {
+        const filePath = this.lanePath(laneId);
+        try {
+            const [content, stats] = await Promise.all([fs.readFile(filePath, "utf8"), fs.stat(filePath)]);
+            const messages = parseJsonLines(content);
+            return buildSnapshot(laneId, messages, Buffer.byteLength(content, "utf8"), stats.mtimeMs);
+        }
+        catch (error) {
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+                return buildSnapshot(laneId, [], 0, 0);
+            }
+            throw error;
+        }
+    }
+    async append(laneId, messages) {
+        const filePath = this.lanePath(laneId);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        const items = Array.isArray(messages) ? messages : [messages];
+        if (items.length) {
+            const payload = `${items.map((item) => JSON.stringify(item)).join("\n")}\n`;
+            await fs.appendFile(filePath, payload, "utf8");
+        }
+        return this.loadLane(laneId);
+    }
+    async replace(laneId, messages) {
+        const filePath = this.lanePath(laneId);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        const payload = messages.length ? `${messages.map((item) => JSON.stringify(item)).join("\n")}\n` : "";
+        await fs.writeFile(filePath, payload, "utf8");
+        return this.loadLane(laneId);
+    }
+    async truncate(laneId, maxMessages) {
+        const snapshot = await this.loadLane(laneId);
+        if (maxMessages < 0) {
+            throw new Error("maxMessages must be non-negative");
+        }
+        if (snapshot.messages.length <= maxMessages) {
+            return snapshot;
+        }
+        const trimmed = maxMessages === 0 ? [] : snapshot.messages.slice(-maxMessages);
+        return this.replace(laneId, trimmed);
+    }
+}

package/dist/vendor/codali/cognitive/ContextSummarizer.d.ts

@@ -0,0 +1,16 @@
+import type { Provider, ProviderMessage } from "../providers/ProviderTypes.js";
+import type { RunLogger } from "../runtime/RunLogger.js";
+export interface ContextSummarizerOptions {
+    temperature?: number;
+    maxTokens?: number;
+    logger?: RunLogger;
+}
+export declare class ContextSummarizer {
+    private provider;
+    private temperature?;
+    private maxTokens?;
+    private logger?;
+    constructor(provider: Provider, options?: ContextSummarizerOptions);
+    summarize(messages: ProviderMessage[]): Promise<ProviderMessage>;
+}
+//# sourceMappingURL=ContextSummarizer.d.ts.map

package/dist/vendor/codali/cognitive/ContextSummarizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextSummarizer.d.ts","sourceRoot":"","sources":["../../src/cognitive/ContextSummarizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,MAAM,WAAW,wBAAwB;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAUD,qBAAa,iBAAiB;IAKhB,OAAO,CAAC,QAAQ;IAJ5B,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAC,CAAY;gBAEP,QAAQ,EAAE,QAAQ,EAAE,OAAO,GAAE,wBAA6B;IAMxE,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,CAAC;CAgCvE"}

package/dist/vendor/codali/cognitive/ContextSummarizer.js

@@ -0,0 +1,45 @@
+import { CONTEXT_SUMMARY_PROMPT } from "./Prompts.js";
+const formatHistory = (messages) => messages
+    .map((message) => {
+    const header = message.name ? `${message.role}(${message.name})` : message.role;
+    return `${header}: ${message.content}`;
+})
+    .join("\n\n");
+export class ContextSummarizer {
+    constructor(provider, options = {}) {
+        this.provider = provider;
+        this.temperature = options.temperature;
+        this.maxTokens = options.maxTokens;
+        this.logger = options.logger;
+    }
+    async summarize(messages) {
+        const requestMessages = [
+            { role: "system", content: CONTEXT_SUMMARY_PROMPT },
+            { role: "user", content: formatHistory(messages) },
+        ];
+        if (this.logger) {
+            await this.logger.log("provider_request", {
+                provider: this.provider.name,
+                messages: requestMessages,
+                temperature: this.temperature,
+                maxTokens: this.maxTokens,
+            });
+        }
+        const response = await this.provider.generate({
+            messages: requestMessages,
+            temperature: this.temperature,
+            maxTokens: this.maxTokens,
+        });
+        if (response.usage && this.logger) {
+            await this.logger.log("context_summarize_usage", { usage: response.usage });
+        }
+        const content = response.message.content?.trim() ?? "";
+        if (!content) {
+            throw new Error("Context summarizer response is empty");
+        }
+        return {
+            role: "system",
+            content: `Context summary: ${content}`,
+        };
+    }
+}

package/dist/vendor/codali/cognitive/CostEstimator.d.ts

@@ -0,0 +1,31 @@
+import type { ProviderUsage } from "../providers/ProviderTypes.js";
+export type PricingSpec = {
+    inputPer1K?: number;
+    outputPer1K?: number;
+    per1K?: number;
+};
+export type PricingOverrides = Record<string, PricingSpec>;
+export interface PricingResolution {
+    pricing?: PricingSpec;
+    source?: string;
+}
+export interface CostEstimate {
+    charCount: number;
+    estimatedInputTokens: number;
+    estimatedOutputTokens: number;
+    estimatedTotalTokens: number;
+    estimatedCost?: number;
+    pricingSource?: string;
+}
+export type UsageCostSource = "actual_usage" | "unknown";
+export type UsageCostReasonCode = "usage_missing" | "pricing_unavailable";
+export interface UsageCostTelemetry {
+    costUsd?: number;
+    source: UsageCostSource;
+    reasonCode?: UsageCostReasonCode;
+}
+export declare const resolvePricing: (overrides: PricingOverrides, provider: string, model: string) => PricingResolution;
+export declare const estimateCostFromChars: (charCount: number, charPerToken: number, pricing?: PricingSpec, pricingSource?: string, outputTokenRatio?: number) => CostEstimate;
+export declare const estimateCostFromUsage: (usage: ProviderUsage | undefined, pricing?: PricingSpec) => number | undefined;
+export declare const estimateUsageCostTelemetry: (usage: ProviderUsage | undefined, pricing?: PricingSpec) => UsageCostTelemetry;
+//# sourceMappingURL=CostEstimator.d.ts.map

package/dist/vendor/codali/cognitive/CostEstimator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CostEstimator.d.ts","sourceRoot":"","sources":["../../src/cognitive/CostEstimator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAE3D,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,SAAS,CAAC;AAEzD,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG,qBAAqB,CAAC;AAE1E,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,mBAAmB,CAAC;CAClC;AAID,eAAO,MAAM,cAAc,GACzB,WAAW,gBAAgB,EAC3B,UAAU,MAAM,EAChB,OAAO,MAAM,KACZ,iBAcF,CAAC;AAmBF,eAAO,MAAM,qBAAqB,GAChC,WAAW,MAAM,EACjB,cAAc,MAAM,EACpB,UAAU,WAAW,EACrB,gBAAgB,MAAM,EACtB,mBAAkB,MAA6B,KAC9C,YAgBF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,OAAO,aAAa,GAAG,SAAS,EAChC,UAAU,WAAW,KACpB,MAAM,GAAG,SAKX,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,OAAO,aAAa,GAAG,SAAS,EAChC,UAAU,WAAW,KACpB,kBAYF,CAAC"}

package/dist/vendor/codali/cognitive/CostEstimator.js

@@ -0,0 +1,66 @@
+const DEFAULT_OUTPUT_RATIO = 0.25;
+export const resolvePricing = (overrides, provider, model) => {
+    const candidates = [
+        `${provider}:${model}`,
+        model,
+        provider,
+        "default",
+    ];
+    for (const key of candidates) {
+        const pricing = overrides[key];
+        if (pricing) {
+            return { pricing, source: key };
+        }
+    }
+    return {};
+};
+const computeCost = (inputTokens, outputTokens, pricing) => {
+    if (!pricing)
+        return undefined;
+    if (pricing.per1K !== undefined) {
+        return ((inputTokens + outputTokens) / 1000) * pricing.per1K;
+    }
+    if (pricing.inputPer1K !== undefined || pricing.outputPer1K !== undefined) {
+        const inputRate = pricing.inputPer1K ?? 0;
+        const outputRate = pricing.outputPer1K ?? 0;
+        return (inputTokens / 1000) * inputRate + (outputTokens / 1000) * outputRate;
+    }
+    return undefined;
+};
+export const estimateCostFromChars = (charCount, charPerToken, pricing, pricingSource, outputTokenRatio = DEFAULT_OUTPUT_RATIO) => {
+    if (charPerToken <= 0) {
+        throw new Error("charPerToken must be greater than zero");
+    }
+    const estimatedInputTokens = Math.ceil(charCount / charPerToken);
+    const estimatedOutputTokens = Math.ceil(estimatedInputTokens * outputTokenRatio);
+    const estimatedTotalTokens = estimatedInputTokens + estimatedOutputTokens;
+    const estimatedCost = computeCost(estimatedInputTokens, estimatedOutputTokens, pricing);
+    return {
+        charCount,
+        estimatedInputTokens,
+        estimatedOutputTokens,
+        estimatedTotalTokens,
+        estimatedCost,
+        pricingSource,
+    };
+};
+export const estimateCostFromUsage = (usage, pricing) => {
+    if (!usage)
+        return undefined;
+    const inputTokens = usage.inputTokens ?? 0;
+    const outputTokens = usage.outputTokens ?? Math.max((usage.totalTokens ?? 0) - inputTokens, 0);
+    return computeCost(inputTokens, outputTokens, pricing);
+};
+export const estimateUsageCostTelemetry = (usage, pricing) => {
+    if (!usage) {
+        return { source: "unknown", reasonCode: "usage_missing" };
+    }
+    if (!pricing) {
+        return { source: "unknown", reasonCode: "pricing_unavailable" };
+    }
+    const costUsd = estimateCostFromUsage(usage, pricing);
+    if (costUsd === undefined) {
+        return { source: "unknown", reasonCode: "pricing_unavailable" };
+    }
+    return { source: "actual_usage", costUsd };
+};

package/dist/vendor/codali/cognitive/CriticEvaluator.d.ts

@@ -0,0 +1,32 @@
+import type { Plan, CriticResult } from "./Types.js";
+import type { ValidationRunner } from "./ValidationRunner.js";
+import type { ContextManager } from "./ContextManager.js";
+import type { RunLogger } from "../runtime/RunLogger.js";
+export interface CriticEvaluatorOptions {
+    contextManager?: ContextManager;
+    laneId?: string;
+    model?: string;
+    logger?: RunLogger;
+}
+export declare class CriticEvaluator {
+    private validator;
+    private contextManager?;
+    private laneId?;
+    private model?;
+    private logger?;
+    constructor(validator: ValidationRunner, options?: CriticEvaluatorOptions);
+    evaluate(plan: Plan, builderOutput: string, touchedFiles?: string[], options?: {
+        contextManager?: ContextManager;
+        laneId?: string;
+        model?: string;
+        allowedPaths?: string[];
+        readOnlyPaths?: string[];
+        allowProtocolRequest?: boolean;
+        logger?: RunLogger;
+        verificationPolicyName?: string;
+        minimumVerificationChecks?: number;
+        enforceHighConfidence?: boolean;
+    }): Promise<CriticResult>;
+    private appendCriticResult;
+}
+//# sourceMappingURL=CriticEvaluator.d.ts.map

package/dist/vendor/codali/cognitive/CriticEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CriticEvaluator.d.ts","sourceRoot":"","sources":["../../src/cognitive/CriticEvaluator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,IAAI,EAEJ,YAAY,EAEb,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,MAAM,WAAW,sBAAsB;IACrC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAsDD,qBAAa,eAAe;IAMd,OAAO,CAAC,SAAS;IAL7B,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,KAAK,CAAC,CAAS;IACvB,OAAO,CAAC,MAAM,CAAC,CAAY;gBAEP,SAAS,EAAE,gBAAgB,EAAE,OAAO,GAAE,sBAA2B;IAO/E,QAAQ,CACZ,IAAI,EAAE,IAAI,EACV,aAAa,EAAE,MAAM,EACrB,YAAY,CAAC,EAAE,MAAM,EAAE,EACvB,OAAO,GAAE;QACP,cAAc,CAAC,EAAE,cAAc,CAAC;QAChC,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,MAAM,CAAC,EAAE,SAAS,CAAC;QACnB,sBAAsB,CAAC,EAAE,MAAM,CAAC;QAChC,yBAAyB,CAAC,EAAE,MAAM,CAAC;QACnC,qBAAqB,CAAC,EAAE,OAAO,CAAC;KAC5B,GACL,OAAO,CAAC,YAAY,CAAC;YA0RV,kBAAkB;CAajC"}

package/dist/vendor/codali/cognitive/CriticEvaluator.js

@@ -0,0 +1,297 @@
+const GUARDRAIL_REASON_PATTERNS = [
+    {
+        code: "scope_violation",
+        pattern: /\b(scope_violation|patch_outside_allowed_scope|patch_outside_workspace)\b/i,
+    },
+    {
+        code: "doc_edit_guard",
+        pattern: /\b(doc_edit_guard|patch_read_only_path)\b/i,
+    },
+    {
+        code: "destructive_operation_guard",
+        pattern: /\b(destructive_operation_guard|destructive_operation_blocked)\b/i,
+    },
+    { code: "merge_conflict", pattern: /\bmerge_conflict\b/i },
+];
+const NON_RETRYABLE_GUARDRAIL_CODES = new Set([
+    "scope_violation",
+    "doc_edit_guard",
+    "merge_conflict",
+    "destructive_operation_guard",
+]);
+const normalizePath = (value) => value.replace(/\\/g, "/").replace(/^\.?\//, "");
+const dedupe = (values) => Array.from(new Set(values));
+const matchesPathRule = (target, rules) => rules.some((entry) => target === entry || target.startsWith(`${entry}/`));
+const detectGuardrailReasonCode = (reasons) => {
+    for (const reason of reasons) {
+        for (const candidate of GUARDRAIL_REASON_PATTERNS) {
+            if (candidate.pattern.test(reason)) {
+                return candidate.code;
+            }
+        }
+    }
+    return undefined;
+};
+const buildGuardrailClassification = (reasonCode) => {
+    if (!reasonCode)
+        return undefined;
+    return {
+        reason_code: reasonCode,
+        disposition: NON_RETRYABLE_GUARDRAIL_CODES.has(reasonCode) ? "non_retryable" : "retryable",
+    };
+};
+export class CriticEvaluator {
+    constructor(validator, options = {}) {
+        this.validator = validator;
+        this.contextManager = options.contextManager;
+        this.laneId = options.laneId;
+        this.model = options.model;
+        this.logger = options.logger;
+    }
+    async evaluate(plan, builderOutput, touchedFiles, options = {}) {
+        if (options.contextManager)
+            this.contextManager = options.contextManager;
+        if (options.laneId)
+            this.laneId = options.laneId;
+        if (options.model)
+            this.model = options.model;
+        if (options.logger)
+            this.logger = options.logger;
+        const verificationPolicyName = options.verificationPolicyName;
+        const minimumVerificationChecks = options.minimumVerificationChecks;
+        const enforceHighConfidence = options.enforceHighConfidence;
+        let verification = {
+            schema_version: 1,
+            outcome: "unverified_with_reason",
+            reason_codes: ["verification_not_executed"],
+            policy: {
+                policy_name: verificationPolicyName ?? "general",
+                minimum_checks: Math.max(0, Math.floor(minimumVerificationChecks ?? 0)),
+                enforce_high_confidence: enforceHighConfidence ?? false,
+            },
+            checks: [],
+            totals: {
+                configured: 0,
+                runnable: 0,
+                attempted: 0,
+                passed: 0,
+                failed: 0,
+                unverified: 0,
+            },
+            touched_files: touchedFiles,
+            language_signals: [],
+        };
+        const targetFiles = (plan.target_files ?? []).filter((file) => file !== "unknown");
+        const normalizedTargetFiles = dedupe(targetFiles.map(normalizePath).filter(Boolean));
+        if (this.logger?.writePhaseArtifact) {
+            await this.logger.writePhaseArtifact("verify", "plan", {
+                schema_version: 1,
+                policy_name: verification.policy.policy_name,
+                source: "pre_validation",
+                touched_files: touchedFiles ?? [],
+                plan_targets: normalizedTargetFiles,
+                configured_steps: plan.verification ?? [],
+            });
+        }
+        const buildAlignmentEvidence = (touched) => {
+            const normalizedTouched = dedupe((touched ?? []).map(normalizePath).filter(Boolean));
+            const matchedTargets = normalizedTargetFiles.filter((target) => normalizedTouched.includes(target));
+            const unmatchedTargets = normalizedTargetFiles.filter((target) => !normalizedTouched.includes(target));
+            const unrelatedTouched = normalizedTouched.filter((file) => !normalizedTargetFiles.includes(file));
+            return {
+                touched_files: normalizedTouched,
+                plan_targets: normalizedTargetFiles,
+                matched_targets: matchedTargets,
+                unmatched_targets: unmatchedTargets,
+                unrelated_touched_files: unrelatedTouched,
+            };
+        };
+        const buildReport = (status, reasons, touched, guardrail, alignmentEvidence, highConfidence) => ({
+            status,
+            reasons,
+            suggested_fixes: reasons.map((reason) => `Address: ${reason}`),
+            touched_files: touched,
+            plan_targets: targetFiles.length ? targetFiles : undefined,
+            alignment_evidence: alignmentEvidence,
+            guardrail,
+            high_confidence: highConfidence,
+            verification,
+        });
+        const buildFailure = (reasons, touched, failureOptions = {}) => {
+            const inferredReasonCode = failureOptions.reasonCode ?? detectGuardrailReasonCode(reasons);
+            const guardrail = buildGuardrailClassification(inferredReasonCode);
+            const retryable = guardrail
+                ? guardrail.disposition === "retryable"
+                : (failureOptions.retryable ?? true);
+            return {
+                status: "FAIL",
+                reasons,
+                retryable,
+                guardrail,
+                high_confidence: false,
+                report: buildReport("FAIL", reasons, touched, guardrail, buildAlignmentEvidence(touched), false),
+            };
+        };
+        const emitSafetyTelemetry = async (result) => {
+            if (!result.guardrail || !this.logger?.logSafetyEvent)
+                return;
+            await this.logger.logSafetyEvent({
+                phase: "verify",
+                category: "critic",
+                code: result.guardrail.reason_code,
+                disposition: result.guardrail.disposition,
+                source: "critic_evaluator",
+                message: result.reasons.join("; ") || "critic guardrail triggered",
+                details: {
+                    reasons: result.reasons,
+                },
+            });
+        };
+        const finalizeFailure = async (reasons, touched, failureOptions = {}) => {
+            const result = buildFailure(reasons, touched, failureOptions);
+            await emitSafetyTelemetry(result);
+            await this.appendCriticResult(result);
+            return result;
+        };
+        const buildRequest = () => ({
+            version: "v1",
+            role: "critic",
+            request_id: `critic-${Date.now()}`,
+            needs: targetFiles.map((file) => ({ type: "file.read", path: file })),
+            context: { summary: "Need target file contents to validate changes." },
+        });
+        if (!builderOutput.trim()) {
+            return finalizeFailure(["builder output is empty"], touchedFiles);
+        }
+        const inferTouchedFiles = (output) => {
+            const trimmed = output.trim();
+            if (!trimmed || !(trimmed.startsWith("{") || trimmed.startsWith("["))) {
+                return undefined;
+            }
+            try {
+                const payload = JSON.parse(trimmed);
+                const patches = Array.isArray(payload.patches) ? payload.patches : [];
+                if (patches.length > 0) {
+                    return patches
+                        .map((patch) => patch.file)
+                        .filter((file) => typeof file === "string" && file.length > 0);
+                }
+                const files = Array.isArray(payload.files) ? payload.files : [];
+                if (files.length > 0) {
+                    return files
+                        .map((entry) => entry.path)
+                        .filter((file) => typeof file === "string" && file.length > 0);
+                }
+            }
+            catch {
+                return undefined;
+            }
+            return undefined;
+        };
+        let effectiveTouched = touchedFiles;
+        if ((!effectiveTouched || effectiveTouched.length === 0) && targetFiles.length > 0) {
+            const inferred = inferTouchedFiles(builderOutput);
+            if (inferred && inferred.length > 0) {
+                effectiveTouched = inferred;
+            }
+        }
+        const allowedPaths = dedupe((options.allowedPaths ?? []).map(normalizePath).filter(Boolean));
+        const readOnlyPaths = dedupe((options.readOnlyPaths ?? []).map(normalizePath).filter(Boolean));
+        if (effectiveTouched && effectiveTouched.length > 0) {
+            const normalizedTouched = effectiveTouched.map(normalizePath);
+            const readOnlyHits = readOnlyPaths.length
+                ? normalizedTouched.filter((file) => matchesPathRule(file, readOnlyPaths))
+                : [];
+            if (readOnlyHits.length) {
+                return finalizeFailure([`touched read-only paths: ${readOnlyHits.join(", ")}`], effectiveTouched, { reasonCode: "doc_edit_guard" });
+            }
+            if (allowedPaths.length) {
+                const invalid = normalizedTouched.filter((file) => !matchesPathRule(file, allowedPaths));
+                if (invalid.length) {
+                    return finalizeFailure([`touched files outside allowed paths: ${invalid.join(", ")}`], effectiveTouched, { reasonCode: "scope_violation" });
+                }
+            }
+        }
+        if (targetFiles.length === 0) {
+            const reasons = ["alignment_missing_plan_targets"];
+            const result = await finalizeFailure(reasons, effectiveTouched, {
+                reasonCode: "scope_violation",
+                retryable: false,
+            });
+            const request = options.allowProtocolRequest ? buildRequest() : undefined;
+            return { ...result, request };
+        }
+        if (!effectiveTouched || effectiveTouched.length === 0) {
+            const reasons = [
+                "alignment_missing_evidence_no_touched_files",
+                "no files were touched for planned targets",
+            ];
+            const result = await finalizeFailure(reasons, effectiveTouched);
+            const request = options.allowProtocolRequest ? buildRequest() : undefined;
+            return { ...result, request };
+        }
+        if (targetFiles.length > 0) {
+            const normalizedTouched = new Set(effectiveTouched.map(normalizePath));
+            const normalizedTargets = targetFiles.map(normalizePath);
+            const matched = normalizedTargets.some((target) => normalizedTouched.has(target));
+            if (!matched) {
+                const reasons = [
+                    "alignment_mismatch_plan_targets",
+                    `touched files do not match plan targets (touched: ${effectiveTouched.join(", ")})`,
+                ];
+                const result = await finalizeFailure(reasons, effectiveTouched, {
+                    reasonCode: "scope_violation",
+                });
+                const request = options.allowProtocolRequest ? buildRequest() : undefined;
+                return { ...result, request };
+            }
+        }
+        const validation = await this.validator.run(plan.verification ?? [], {
+            policyName: verificationPolicyName,
+            minimumChecks: minimumVerificationChecks,
+            enforceHighConfidence,
+            touchedFiles: effectiveTouched,
+            onResolvedPlan: async (resolvedPlan) => {
+                if (!this.logger?.writePhaseArtifact)
+                    return;
+                await this.logger.writePhaseArtifact("verify", "plan", {
+                    ...resolvedPlan,
+                    plan_targets: normalizedTargetFiles,
+                });
+            },
+        });
+        verification = validation.report;
+        if (verification.outcome === "verified_failed") {
+            return finalizeFailure(validation.errors, effectiveTouched);
+        }
+        if (verification.outcome === "unverified_with_reason" && verification.policy.enforce_high_confidence) {
+            const reasons = verification.reason_codes.map((code) => `verification_${code}`);
+            return finalizeFailure(reasons.length > 0 ? reasons : ["verification_unverified_with_reason"], effectiveTouched, { retryable: false });
+        }
+        const highConfidence = verification.outcome === "verified_passed";
+        const result = {
+            status: "PASS",
+            reasons: [],
+            retryable: false,
+            high_confidence: highConfidence,
+            verification,
+            report: buildReport("PASS", [], effectiveTouched, undefined, buildAlignmentEvidence(effectiveTouched), highConfidence),
+        };
+        await this.appendCriticResult(result);
+        return result;
+    }
+    async appendCriticResult(result) {
+        if (!this.contextManager || !this.laneId)
+            return;
+        const payload = result.report ?? {
+            status: result.status,
+            reasons: result.reasons,
+            suggested_fixes: [],
+        };
+        const message = {
+            role: "assistant",
+            content: `CRITIC_RESULT v1\n${JSON.stringify(payload, null, 2)}`,
+        };
+        await this.contextManager.append(this.laneId, message, { role: "critic", model: this.model });
+    }
+}

package/dist/vendor/codali/cognitive/EvidenceGate.d.ts

@@ -0,0 +1,9 @@
+import type { DeepInvestigationEvidenceConfig } from "../config/Config.js";
+import type { ContextResearchEvidence, ContextResearchToolUsage, EvidenceGateAssessment } from "./Types.js";
+export declare const evaluateEvidenceGate: ({ config, evidence, toolUsage, warnings, }: {
+    config: DeepInvestigationEvidenceConfig;
+    evidence?: ContextResearchEvidence;
+    toolUsage?: ContextResearchToolUsage;
+    warnings?: string[];
+}) => EvidenceGateAssessment;
+//# sourceMappingURL=EvidenceGate.d.ts.map

package/dist/vendor/codali/cognitive/EvidenceGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvidenceGate.d.ts","sourceRoot":"","sources":["../../src/cognitive/EvidenceGate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,KAAK,EACV,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EAGvB,MAAM,YAAY,CAAC;AA4EpB,eAAO,MAAM,oBAAoB,GAAI,4CAKlC;IACD,MAAM,EAAE,+BAA+B,CAAC;IACxC,QAAQ,CAAC,EAAE,uBAAuB,CAAC;IACnC,SAAS,CAAC,EAAE,wBAAwB,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB,KAAG,sBAwBH,CAAC"}