@danielblomma/cortex-mcp 2.0.16 → 2.0.18

package/scaffold/mcp/src/enterprise/reviews/policy-selection.ts

@@ -0,0 +1,65 @@
+import type { OrgPolicy } from "../../core/policy/store.js";
+import {
+  getGenericEvaluator,
+  getValidator,
+  type EnforcedPolicy,
+} from "../../core/validators/engine.js";
+import type { ReviewSkippedPolicy } from "./trust-state.js";
+
+export const DEFERRED_CODE_REVIEW_REASON =
+  "Current context.review invocation is the review being recorded; validate this policy from workflow state on the next run.";
+
+export type PartitionedReviewPolicies = {
+  enforced: EnforcedPolicy[];
+  skipped: ReviewSkippedPolicy[];
+};
+
+export function partitionReviewPolicies(
+  policies: OrgPolicy[],
+): PartitionedReviewPolicies {
+  const enforced: EnforcedPolicy[] = [];
+  const skipped: ReviewSkippedPolicy[] = [];
+
+  for (const policy of policies) {
+    if (!policy.enforce) continue;
+
+    if (policy.id === "require-code-review") {
+      skipped.push({
+        policy_id: policy.id,
+        kind: policy.kind ?? null,
+        type: policy.type ?? null,
+        reason: DEFERRED_CODE_REVIEW_REASON,
+      });
+      continue;
+    }
+
+    if (policy.type) {
+      if (!getGenericEvaluator(policy.type)) {
+        skipped.push({
+          policy_id: policy.id,
+          kind: policy.kind ?? null,
+          type: policy.type,
+          reason: `No evaluator registered for type "${policy.type}"`,
+        });
+        continue;
+      }
+    } else if (!getValidator(policy.id)) {
+      skipped.push({
+        policy_id: policy.id,
+        kind: policy.kind ?? null,
+        type: null,
+        reason: "No executable validator registered for this policy",
+      });
+      continue;
+    }
+
+    enforced.push({
+      id: policy.id,
+      type: policy.type ?? null,
+      config: policy.config ?? null,
+      severity: policy.severity ?? "block",
+    });
+  }
+
+  return { enforced, skipped };
+}

package/scaffold/mcp/src/enterprise/reviews/push.ts

@@ -1,3 +1,5 @@
+import { recordReviewDeliveryStatus } from "./trust-state.js";
+
 export type ReviewPushItem = {
   policy_id: string;
   pass: boolean;
@@ -11,12 +13,16 @@ export type ReviewPushContext = {
   repo?: string;
   instance_id?: string;
   session_id?: string;
+  context_dir?: string;
+  project_root?: string;
 };
 
 export type ReviewPushResult = {
   success: boolean;
   count: number;
   error?: string;
+  attempted?: boolean;
+  delivery_status?: "accepted" | "failed";
 };
 
 const pending: ReviewPushItem[] = [];
@@ -26,6 +32,10 @@ export function setReviewPushContext(context: ReviewPushContext): void {
   activeContext = { ...context };
 }
 
+export function getReviewPushContext(): ReviewPushContext {
+  return { ...activeContext };
+}
+
 export function queueReviewResult(item: ReviewPushItem): void {
   pending.push(item);
 }
@@ -39,11 +49,18 @@ export async function pushReviewResults(
   apiKey: string,
 ): Promise<ReviewPushResult> {
   if (pending.length === 0) {
-    return { success: true, count: 0 };
+    return { success: true, count: 0, attempted: false };
   }
 
   const reviewsUrl = `${baseUrl.replace(/\/$/, "")}/api/v1/reviews/push`;
   const batch = pending.splice(0, 100);
+  const attemptedAt = new Date().toISOString();
+  if (activeContext.context_dir) {
+    recordReviewDeliveryStatus(activeContext.context_dir, "pushed", {
+      reviewCount: batch.length,
+      attemptedAt,
+    });
+  }
 
   try {
     const response = await fetch(reviewsUrl, {
@@ -64,16 +81,50 @@ export async function pushReviewResults(
 
     if (!response.ok) {
       pending.unshift(...batch);
-      return { success: false, count: 0, error: `HTTP ${response.status}` };
+      if (activeContext.context_dir) {
+        recordReviewDeliveryStatus(activeContext.context_dir, "failed", {
+          reviewCount: batch.length,
+          attemptedAt,
+          error: `HTTP ${response.status}`,
+        });
+      }
+      return {
+        success: false,
+        count: 0,
+        error: `HTTP ${response.status}`,
+        attempted: true,
+        delivery_status: "failed",
+      };
     }
 
-    return { success: true, count: batch.length };
+    if (activeContext.context_dir) {
+      recordReviewDeliveryStatus(activeContext.context_dir, "accepted", {
+        reviewCount: batch.length,
+        attemptedAt,
+      });
+    }
+    return {
+      success: true,
+      count: batch.length,
+      attempted: true,
+      delivery_status: "accepted",
+    };
   } catch (err) {
     pending.unshift(...batch);
+    const error = err instanceof Error ? err.message : "unknown error";
+    if (activeContext.context_dir) {
+      recordReviewDeliveryStatus(activeContext.context_dir, "failed", {
+        reviewCount: batch.length,
+        attemptedAt,
+        error,
+      });
+    }
     return {
       success: false,
       count: 0,
-      error: err instanceof Error ? err.message : "unknown error",
+      error,
+      attempted: true,
+      delivery_status: "failed",
     };
   }
 }

package/scaffold/mcp/src/enterprise/reviews/trust-state.ts

@@ -0,0 +1,305 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { setWorkflowReviewTrust } from "../workflow/state.js";
+import { resolveWorkflowDefinition, type WorkflowSource } from "../../core/workflow/resolution.js";
+
+export type ReviewDeliveryStatus =
+  | "never_attempted"
+  | "queued"
+  | "pushed"
+  | "accepted"
+  | "failed";
+
+export type ReviewTrustWarning = {
+  code:
+    | "workflow-source-unverified"
+    | "workflow-unresolved"
+    | "review-delivery-pending"
+    | "review-delivery-failed"
+    | "policy-not-enforceable";
+  message: string;
+};
+
+export type ReviewSkippedPolicy = {
+  policy_id: string;
+  kind: string | null;
+  type: string | null;
+  reason: string;
+};
+
+export type ReviewTrustState = {
+  version: 1;
+  repo: string | null;
+  instance_id: string | null;
+  session_id: string | null;
+  workflow: {
+    id: string | null;
+    source: WorkflowSource | "unknown";
+    task_id: string | null;
+  };
+  last_review_at: string | null;
+  review_summary: {
+    total: number;
+    passed: number;
+    failed: number;
+    warnings: number;
+    skipped: number;
+  } | null;
+  skipped_policies: ReviewSkippedPolicy[];
+  delivery: {
+    status: ReviewDeliveryStatus;
+    review_count: number;
+    queued_at: string | null;
+    last_attempted_at: string | null;
+    last_pushed_at: string | null;
+    last_accepted_at: string | null;
+    last_error: string | null;
+  };
+  trust_warnings: ReviewTrustWarning[];
+};
+
+type TrustContext = {
+  contextDir: string;
+  projectRoot: string;
+  repo?: string;
+  instance_id?: string;
+  session_id?: string;
+  task_id?: string;
+};
+
+type ReviewSummaryInput = {
+  total: number;
+  passed: number;
+  failed: number;
+  warnings: number;
+  skipped: number;
+};
+
+type WorkflowInference = {
+  id: string | null;
+  source: WorkflowSource | "unknown";
+  task_id: string | null;
+};
+
+function trustStatePath(contextDir: string): string {
+  return join(contextDir, "review-trust.json");
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function initialTrustState(): ReviewTrustState {
+  return {
+    version: 1,
+    repo: null,
+    instance_id: null,
+    session_id: null,
+    workflow: {
+      id: null,
+      source: "unknown",
+      task_id: null,
+    },
+    last_review_at: null,
+    review_summary: null,
+    skipped_policies: [],
+    delivery: {
+      status: "never_attempted",
+      review_count: 0,
+      queued_at: null,
+      last_attempted_at: null,
+      last_pushed_at: null,
+      last_accepted_at: null,
+      last_error: null,
+    },
+    trust_warnings: [],
+  };
+}
+
+function ensureContextDir(contextDir: string): void {
+  mkdirSync(contextDir, { recursive: true });
+}
+
+function inferWorkflow(projectRoot: string, taskId?: string): WorkflowInference {
+  const normalizedTaskId = taskId?.trim();
+  if (!normalizedTaskId) {
+    return { id: null, source: "unknown", task_id: null };
+  }
+
+  const statePath = join(projectRoot, ".agents", normalizedTaskId, "state.json");
+  if (!existsSync(statePath)) {
+    return { id: null, source: "unknown", task_id: normalizedTaskId };
+  }
+
+  try {
+    const raw = JSON.parse(readFileSync(statePath, "utf8")) as Record<string, unknown>;
+    const workflowId =
+      typeof raw.workflow_id === "string" ? raw.workflow_id : null;
+    if (!workflowId) {
+      return { id: null, source: "unknown", task_id: normalizedTaskId };
+    }
+    const resolved = resolveWorkflowDefinition(workflowId);
+    return {
+      id: workflowId,
+      source: resolved.source,
+      task_id: normalizedTaskId,
+    };
+  } catch {
+    return {
+      id: null,
+      source: "unknown",
+      task_id: normalizedTaskId,
+    };
+  }
+}
+
+function computeWarnings(state: ReviewTrustState): ReviewTrustWarning[] {
+  const warnings: ReviewTrustWarning[] = [];
+
+  if (!state.workflow.id) {
+    warnings.push({
+      code: "workflow-unresolved",
+      message:
+        "No active local workflow could be resolved for this review session, so workflow/review correlation is unproven.",
+    });
+  } else if (state.workflow.source !== "synced") {
+    warnings.push({
+      code: "workflow-source-unverified",
+      message:
+        `Workflow "${state.workflow.id}" is not proven to come from the synced org registry for this session.`,
+    });
+  }
+
+  if (state.delivery.status === "queued" || state.delivery.status === "pushed") {
+    warnings.push({
+      code: "review-delivery-pending",
+      message:
+        "Local review results exist for this session, but Cortex has not yet confirmed acceptance by the control plane.",
+    });
+  }
+
+  if (state.delivery.status === "failed") {
+    warnings.push({
+      code: "review-delivery-failed",
+      message:
+        `Review delivery failed${state.delivery.last_error ? `: ${state.delivery.last_error}` : ""}`,
+    });
+  }
+
+  if (state.skipped_policies.length > 0) {
+    warnings.push({
+      code: "policy-not-enforceable",
+      message:
+        `${state.skipped_policies.length} configured policy` +
+        `${state.skipped_policies.length === 1 ? " was" : "ies were"} not enforceable locally.`,
+    });
+  }
+
+  return warnings;
+}
+
+export function loadReviewTrustState(contextDir: string): ReviewTrustState {
+  ensureContextDir(contextDir);
+  const filePath = trustStatePath(contextDir);
+  if (!existsSync(filePath)) {
+    const initial = initialTrustState();
+    writeReviewTrustState(contextDir, initial);
+    return initial;
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, "utf8")) as ReviewTrustState;
+    parsed.trust_warnings = computeWarnings(parsed);
+    return parsed;
+  } catch {
+    const initial = initialTrustState();
+    writeReviewTrustState(contextDir, initial);
+    return initial;
+  }
+}
+
+export function writeReviewTrustState(
+  contextDir: string,
+  state: ReviewTrustState,
+): ReviewTrustState {
+  ensureContextDir(contextDir);
+  state.trust_warnings = computeWarnings(state);
+  writeFileSync(trustStatePath(contextDir), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+  setWorkflowReviewTrust(contextDir, state);
+  return state;
+}
+
+export function recordQueuedReviewTrustState(
+  context: TrustContext,
+  input: {
+    reviewedAt: string;
+    summary: ReviewSummaryInput;
+    skippedPolicies: ReviewSkippedPolicy[];
+  },
+): ReviewTrustState {
+  const state = loadReviewTrustState(context.contextDir);
+  const workflow = inferWorkflow(context.projectRoot, context.task_id);
+  state.repo = context.repo ?? state.repo;
+  state.instance_id = context.instance_id ?? state.instance_id;
+  state.session_id = context.session_id ?? state.session_id;
+  state.workflow = workflow;
+  state.last_review_at = input.reviewedAt;
+  state.review_summary = {
+    total: input.summary.total,
+    passed: input.summary.passed,
+    failed: input.summary.failed,
+    warnings: input.summary.warnings,
+    skipped: input.summary.skipped,
+  };
+  state.skipped_policies = input.skippedPolicies;
+  const hasQueuedReviews = input.summary.total > 0;
+  state.delivery = {
+    status: hasQueuedReviews ? "queued" : "never_attempted",
+    review_count: input.summary.total,
+    queued_at: hasQueuedReviews ? input.reviewedAt : null,
+    last_attempted_at: null,
+    last_pushed_at: null,
+    last_accepted_at: null,
+    last_error: null,
+  };
+  return writeReviewTrustState(context.contextDir, state);
+}
+
+export function recordReviewDeliveryStatus(
+  contextDir: string,
+  status: ReviewDeliveryStatus,
+  input: {
+    reviewCount?: number;
+    error?: string;
+    attemptedAt?: string;
+  } = {},
+): ReviewTrustState {
+  const state = loadReviewTrustState(contextDir);
+  const at = input.attemptedAt ?? nowIso();
+  state.delivery.review_count = input.reviewCount ?? state.delivery.review_count;
+  state.delivery.last_attempted_at = at;
+
+  if (status === "pushed") {
+    state.delivery.status = "pushed";
+    state.delivery.last_pushed_at = at;
+    state.delivery.last_error = null;
+  } else if (status === "accepted") {
+    state.delivery.status = "accepted";
+    state.delivery.last_pushed_at = at;
+    state.delivery.last_accepted_at = at;
+    state.delivery.last_error = null;
+  } else if (status === "failed") {
+    state.delivery.status = "failed";
+    state.delivery.last_pushed_at = at;
+    state.delivery.last_error = input.error ?? "unknown error";
+  } else {
+    state.delivery.status = status;
+  }
+
+  return writeReviewTrustState(contextDir, state);
+}

package/scaffold/mcp/src/enterprise/tools/enterprise.ts

@@ -13,7 +13,9 @@ import type { InjectionMatch } from "../../core/policy/injection.js";
 import { getLastPush } from "../telemetry/sync.js";
 import { syncFromCloud, syncFromLocal, getLastSync } from "../policy/sync.js";
 import { queueViolation } from "../violations/push.js";
-import { queueReviewResult } from "../reviews/push.js";
+import { getReviewPushContext, queueReviewResult } from "../reviews/push.js";
+import { partitionReviewPolicies } from "../reviews/policy-selection.js";
+import { recordQueuedReviewTrustState } from "../reviews/trust-state.js";
 import { pushWorkflowSnapshot } from "../workflow/push.js";
 import { OUTBOUND_DATA_BOUNDARY } from "../privacy/boundary.js";
 import {
@@ -31,11 +33,7 @@ import {
 } from "../workflow/state.js";
 import { queryAuditLog } from "../../core/audit/query.js";
 import { checkAccess, getAccessDeniedMessage, type Role } from "../../core/rbac/check.js";
-import {
-  getGenericEvaluator,
-  getValidator,
-  runValidators,
-} from "../../core/validators/engine.js";
+import { runValidators } from "../../core/validators/engine.js";
 import "../../core/validators/builtins.js";
 import { recordToolActivity } from "../index.js";
 
@@ -904,41 +902,10 @@ export function registerEnterpriseTools(
       // rules. Predefined rules leave type/config null and route to the
       // name-based validator registry.
       const policies = policyStore.getMergedPolicies();
-      const skippedPolicies = policies
-        .filter((p) => p.enforce)
-        .filter((p) => p.id === "require-code-review" || (p.type ? !getGenericEvaluator(p.type) : !getValidator(p.id)))
-        .map((p) => {
-          if (p.id === "require-code-review") {
-            return {
-              policy_id: p.id,
-              kind: p.kind ?? null,
-              type: p.type ?? null,
-              reason: "Current context.review invocation is the review being recorded; validate this policy from workflow state on the next run.",
-            };
-          }
-          return {
-            policy_id: p.id,
-            kind: p.kind ?? null,
-            type: p.type ?? null,
-            reason: p.type
-              ? `No evaluator registered for type "${p.type}"`
-              : "No executable validator registered for this policy",
-          };
-        });
-
-      const enforced = policies
-        .filter((p) => p.enforce)
-        .filter((p) => {
-          if (p.id === "require-code-review") return false;
-          if (p.type) return Boolean(getGenericEvaluator(p.type));
-          return Boolean(getValidator(p.id));
-        })
-        .map((p) => ({
-          id: p.id,
-          type: p.type ?? null,
-          config: p.config ?? null,
-          severity: p.severity ?? "block",
-        }));
+      const {
+        enforced,
+        skipped: skippedPolicies,
+      } = partitionReviewPolicies(policies);
 
       const now = new Date().toISOString();
 
@@ -964,9 +931,9 @@ export function registerEnterpriseTools(
             occurred_at: now,
           });
         }
-        queueReviewResult({
-          policy_id: r.policy_id,
-          pass: r.pass,
+          queueReviewResult({
+            policy_id: r.policy_id,
+            pass: r.pass,
           severity: r.severity,
           message: r.message,
           detail: r.detail,
@@ -1001,20 +968,43 @@ export function registerEnterpriseTools(
         reviewed_files: reviewedFiles,
       });
       const lastReview = workflowState.last_review;
+      const reviewedAt = lastReview?.reviewed_at ?? now;
       if (lastReview) {
         writeFileSync(
           join(contextDir, "review-status.json"),
           `${JSON.stringify({
             reviewed: lastReview.status === "passed",
             reviewer: "context.review",
-            timestamp: lastReview.reviewed_at,
+            timestamp: reviewedAt,
             scope: parsed.scope,
             reviewed_files: reviewedFiles,
           }, null, 2)}\n`,
           "utf8",
         );
       }
-      await pushWorkflowStateIfConfigured(config, workflowState);
+      const trustState = recordQueuedReviewTrustState(
+        {
+          contextDir,
+          projectRoot,
+          repo: getReviewPushContext().repo,
+          instance_id: getReviewPushContext().instance_id,
+          session_id: getReviewPushContext().session_id,
+          task_id: process.env.CORTEX_ACTIVE_TASK_ID?.trim() || undefined,
+        },
+        {
+          reviewedAt,
+          summary: {
+            total: output.summary.total,
+            passed: output.summary.passed,
+            failed: output.summary.failed,
+            warnings: output.summary.warnings,
+            skipped: skippedPolicies.length,
+          },
+          skippedPolicies: skippedPolicies,
+        },
+      );
+      const workflowWithTrust = loadWorkflowState(contextDir);
+      await pushWorkflowStateIfConfigured(config, workflowWithTrust);
 
       return buildToolResult({
         scope: parsed.scope,
@@ -1024,7 +1014,10 @@ export function registerEnterpriseTools(
           ...output.summary,
           skipped: skippedPolicies.length,
         },
-        workflow: workflowState,
+        workflow: workflowWithTrust,
+        workflow_source: trustState.workflow.source,
+        delivery: trustState.delivery,
+        trust_warnings: trustState.trust_warnings,
       });
     },
   );

package/scaffold/mcp/src/enterprise/tools/harness.ts

@@ -1,4 +1,5 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { isEnforcedMode } from "../../hooks/shared.js";
 import {
   WorkflowAdvanceInput,
   WorkflowEnvelopeInput,
@@ -38,6 +39,7 @@ export function registerHarnessTools(server: McpServer): void {
     async (input) => buildResult(
       runWorkflowStart(WorkflowStartInput.parse(input ?? {}), {
         cwd: resolveProjectRoot(),
+        bundledFallbackPolicy: isEnforcedMode(resolveProjectRoot()) ? "block" : "allow",
       }) as ToolPayload,
     ),
   );

package/scaffold/mcp/src/enterprise/workflow/state.ts

@@ -10,6 +10,7 @@ import type {
   ReviewResult,
   ReviewSummary,
 } from "../../core/validators/engine.js";
+import type { ReviewTrustState } from "../reviews/trust-state.js";
 
 export type WorkflowPhase =
   | "planning"
@@ -111,6 +112,7 @@ export type WorkflowState = {
   notes: WorkflowNote[];
   todos: WorkflowTodo[];
   history: WorkflowHistoryEntry[];
+  review_trust: ReviewTrustState | null;
 };
 
 export type WorkflowMutationResult = {
@@ -145,6 +147,10 @@ function workflowStatePath(contextDir: string): string {
   return join(workflowDir(contextDir), "state.json");
 }
 
+export function hasWorkflowState(contextDir: string): boolean {
+  return existsSync(workflowStatePath(contextDir));
+}
+
 function workflowReviewsDir(contextDir: string): string {
   return join(workflowDir(contextDir), "reviews");
 }
@@ -195,6 +201,7 @@ function initialState(): WorkflowState {
     notes: [],
     todos: [],
     history: [],
+    review_trust: null,
   };
 }
 
@@ -457,6 +464,20 @@ export function recordWorkflowUpdate(
   );
 }
 
+export function setWorkflowReviewTrust(
+  contextDir: string,
+  reviewTrust: ReviewTrustState,
+): WorkflowState {
+  if (!hasWorkflowState(contextDir)) {
+    const state = initialState();
+    state.review_trust = reviewTrust;
+    return writeState(contextDir, withRecalculatedApproval(state, true));
+  }
+  const state = loadWorkflowState(contextDir);
+  state.review_trust = reviewTrust;
+  return writeState(contextDir, withRecalculatedApproval(state, true));
+}
+
 export function addWorkflowNote(
   contextDir: string,
   input: { title: string; details: string }