@bitkyc08/opencodex 2.12.0 → 2.13.0

package/src/lab/projection/verdicts.ts

@@ -301,6 +301,50 @@ function isMatchedCapabilityAbsenceControl(obs: ObservationEvent): boolean {
   );
 }
 
+function evaluateRequiredPassVerdict(input: {
+  suiteManifest: SuiteManifestV1 | null;
+  ordered: ObservationEvent[];
+  executionMode: ObservationEvent["executionMode"];
+  subject?: ObservationEvent["subject"];
+  routeSupportedClaims?: readonly string[];
+  fabricCapability?: {
+    harnessFeatures: readonly string[];
+    platforms: readonly string[];
+    routePreconditions: readonly string[];
+  };
+  loadScenarioManifest?: (digest: string) => Record<string, unknown> | null;
+  loadScenarioRequirements?: ProjectVerdictsOptions["loadScenarioRequirements"];
+  asOf: number;
+}): { verdict: CompatibilityVerdict; notes: string[] } {
+  const notes: string[] = [];
+  if (!input.suiteManifest) {
+    return { verdict: "PROBED", notes: ["suite_manifest_unavailable"] };
+  }
+  const evaluation = evaluateAllApplicableRequiredPassV1(
+    input.suiteManifest,
+    input.ordered,
+    input.executionMode,
+    {
+      subject: input.subject,
+      routeSupportedClaims: input.routeSupportedClaims,
+      fabricCapability: input.fabricCapability,
+      loadScenarioManifest: input.loadScenarioManifest,
+      loadScenarioRequirements: input.loadScenarioRequirements,
+      asOf: input.asOf,
+    },
+  );
+  notes.push(...evaluation.notes);
+  if (evaluation.applicableRequiredScenarioIds.length === 0) {
+    return { verdict: "UNKNOWN", notes };
+  }
+  if (evaluation.canVerify) {
+    notes.push("all-applicable-required-pass-v1");
+    return { verdict: "VERIFIED", notes };
+  }
+  notes.push("incomplete_required_coverage");
+  return { verdict: "PROBED", notes };
+}
+
 function projectObservationGroup(
   key: ProjectionKey,
   ordered: ObservationEvent[],
@@ -310,6 +354,11 @@ function projectObservationGroup(
     loadScenarioManifest?: (digest: string) => Record<string, unknown> | null;
     loadScenarioRequirements?: ProjectVerdictsOptions["loadScenarioRequirements"];
     routeSupportedClaims?: readonly string[];
+    fabricCapability?: {
+      harnessFeatures: readonly string[];
+      platforms: readonly string[];
+      routePreconditions: readonly string[];
+    };
   } = {},
 ): DerivedVerdict {
   const contributing: string[] = [];
@@ -353,60 +402,47 @@ function projectObservationGroup(
       verdict = "PROBED";
       notes.push("mixed_execution_modes");
     } else if (key.evidenceLayer === "protocol_conformance" && newestCurrent?.executionMode === "fixture") {
-      if (!suiteManifest) {
-        verdict = "PROBED";
-        notes.push("suite_manifest_unavailable");
-      } else {
-        const evaluation = evaluateAllApplicableRequiredPassV1(
-          suiteManifest,
-          ordered,
-          newestCurrent.executionMode,
-          {
-            subject: newestCurrent.subject.subjectKind === "protocol" ? newestCurrent.subject : undefined,
-            loadScenarioManifest: opts.loadScenarioManifest,
-            loadScenarioRequirements: opts.loadScenarioRequirements,
-            asOf,
-          },
-        );
-        notes.push(...evaluation.notes);
-        if (evaluation.applicableRequiredScenarioIds.length === 0) {
-          verdict = "UNKNOWN";
-        } else if (evaluation.canVerify) {
-          verdict = "VERIFIED";
-          notes.push("all-applicable-required-pass-v1");
-        } else {
-          verdict = "PROBED";
-          notes.push("incomplete_required_coverage");
-        }
-      }
+      const evaluated = evaluateRequiredPassVerdict({
+        suiteManifest,
+        ordered,
+        executionMode: newestCurrent.executionMode,
+        subject: newestCurrent.subject.subjectKind === "protocol" ? newestCurrent.subject : undefined,
+        loadScenarioManifest: opts.loadScenarioManifest,
+        loadScenarioRequirements: opts.loadScenarioRequirements,
+        asOf,
+      });
+      verdict = evaluated.verdict;
+      notes.push(...evaluated.notes);
     } else if (key.evidenceLayer === "live_route_compatibility" && newestCurrent?.executionMode === "live") {
-      if (!suiteManifest) {
-        verdict = "PROBED";
-        notes.push("suite_manifest_unavailable");
-      } else {
-        const evaluation = evaluateAllApplicableRequiredPassV1(
-          suiteManifest,
-          ordered,
-          newestCurrent.executionMode,
-          {
-            subject: newestCurrent.subject.subjectKind === "route" ? newestCurrent.subject : undefined,
-            routeSupportedClaims: opts.routeSupportedClaims,
-            loadScenarioManifest: opts.loadScenarioManifest,
-            loadScenarioRequirements: opts.loadScenarioRequirements,
-            asOf,
-          },
-        );
-        notes.push(...evaluation.notes);
-        if (evaluation.applicableRequiredScenarioIds.length === 0) {
-          verdict = "UNKNOWN";
-        } else if (evaluation.canVerify) {
-          verdict = "VERIFIED";
-          notes.push("all-applicable-required-pass-v1");
-        } else {
-          verdict = "PROBED";
-          notes.push("incomplete_required_coverage");
-        }
-      }
+      const evaluated = evaluateRequiredPassVerdict({
+        suiteManifest,
+        ordered,
+        executionMode: newestCurrent.executionMode,
+        subject: newestCurrent.subject.subjectKind === "route" ? newestCurrent.subject : undefined,
+        routeSupportedClaims: opts.routeSupportedClaims,
+        loadScenarioManifest: opts.loadScenarioManifest,
+        loadScenarioRequirements: opts.loadScenarioRequirements,
+        asOf,
+      });
+      verdict = evaluated.verdict;
+      notes.push(...evaluated.notes);
+    } else if (key.evidenceLayer === "task_effectiveness" && newestCurrent?.executionMode === "fabric") {
+      const evaluated = evaluateRequiredPassVerdict({
+        suiteManifest,
+        ordered,
+        executionMode: newestCurrent.executionMode,
+        subject: newestCurrent.subject.subjectKind === "task" ? newestCurrent.subject : undefined,
+        fabricCapability: opts.fabricCapability ?? {
+          harnessFeatures: ["fabric-scratch-v1"],
+          platforms: [process.platform, "*"],
+          routePreconditions: ["exact-route-subject"],
+        },
+        loadScenarioManifest: opts.loadScenarioManifest,
+        loadScenarioRequirements: opts.loadScenarioRequirements,
+        asOf,
+      });
+      verdict = evaluated.verdict;
+      notes.push(...evaluated.notes);
     } else {
       verdict = "PROBED";
     }

package/src/lab/projection/verification.ts

@@ -1,4 +1,4 @@
-import type { ObservationEvent, ProtocolSubjectV1, RouteSubjectV1 } from "../events/types";
+import type { ObservationEvent, ProtocolSubjectV1, RouteSubjectV1, TaskSubjectV1 } from "../events/types";
 import { EVIDENCE_LAYERS, type ExecutionMode } from "../constants";
 import type { SuiteManifestV1 } from "../conformance/suite-manifest";
 import type { VerificationRole } from "../conformance/types";
@@ -19,6 +19,9 @@ export interface ScenarioRequirements {
   upstreamProtocols?: string[];
   surfaces?: string[];
   requiredClaims?: string[];
+  requiredHarnessFeatures?: string[];
+  platforms?: string[];
+  routePreconditions?: string[];
   freshness?: { maxAgeMs: number | null };
 }
 
@@ -38,6 +41,7 @@ export function isScenarioApplicable(
   return true;
 }
 
+/** Match protocol subject fields against scenario requirement lists. */
 function scenarioApplicableToRequirements(
   requirements: ScenarioRequirements,
   subject: ProtocolSubjectV1,
@@ -71,10 +75,32 @@ export function routeSubjectApplicableToRequirements(
   );
 }
 
+/** Task-layer applicability against harness/platform/precondition state. */
+export function taskSubjectApplicableToRequirements(
+  requirements: ScenarioRequirements,
+  capability: {
+    harnessFeatures: readonly string[];
+    platforms: readonly string[];
+    routePreconditions: readonly string[];
+  },
+): boolean {
+  const platforms = requirements.platforms ?? ["*"];
+  const features = requirements.requiredHarnessFeatures ?? [];
+  const preconditions = requirements.routePreconditions ?? [];
+  const platformOk = platforms.includes("*")
+    || capability.platforms.includes("*")
+    || platforms.some((platform) => capability.platforms.includes(platform));
+  const featuresOk = features.every((feature) => capability.harnessFeatures.includes(feature));
+  const preconditionsOk = preconditions.every((item) => capability.routePreconditions.includes(item));
+  return platformOk && featuresOk && preconditionsOk;
+}
+
+/** Return true for non-negative integer values used in freshness parsing. */
 function isNonNegativeInteger(value: unknown): value is number {
   return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
 
+/** Parse a freshness object from a scenario manifest fragment. */
 function parseFreshness(value: unknown): { maxAgeMs: number | null } | null {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const maxAgeMs = (value as { maxAgeMs?: unknown }).maxAgeMs;
@@ -83,6 +109,7 @@ function parseFreshness(value: unknown): { maxAgeMs: number | null } | null {
   return { maxAgeMs };
 }
 
+/** Parse a string array requirement field from a manifest fragment. */
 function parseStringArray(value: unknown): string[] | null {
   if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) return null;
   return value;
@@ -101,9 +128,28 @@ function scenarioContractFromManifest(
   if (!inboundProtocols || !upstreamProtocols || !surfaces) return null;
   const requiredClaims = row.requiredClaims === undefined ? [] : parseStringArray(row.requiredClaims);
   if (!requiredClaims) return null;
+  const requiredHarnessFeatures = row.requiredHarnessFeatures === undefined
+    ? []
+    : parseStringArray(row.requiredHarnessFeatures);
+  if (!requiredHarnessFeatures) return null;
+  const platforms = row.platforms === undefined ? ["*"] : parseStringArray(row.platforms);
+  if (!platforms) return null;
+  const routePreconditions = row.routePreconditions === undefined
+    ? []
+    : parseStringArray(row.routePreconditions);
+  if (!routePreconditions) return null;
   const freshness = parseFreshness(scenarioManifest.freshness);
   if (!freshness) return null;
-  return { inboundProtocols, upstreamProtocols, surfaces, requiredClaims, freshness };
+  return {
+    inboundProtocols,
+    upstreamProtocols,
+    surfaces,
+    requiredClaims,
+    requiredHarnessFeatures,
+    platforms,
+    routePreconditions,
+    freshness,
+  };
 }
 
 function effectiveMaxAgeMs(
@@ -139,9 +185,15 @@ export function evaluateAllApplicableRequiredPassV1(
   observations: ObservationEvent[],
   executionMode: ExecutionMode,
   opts: {
-    subject?: ProtocolSubjectV1 | RouteSubjectV1;
+    subject?: ProtocolSubjectV1 | RouteSubjectV1 | TaskSubjectV1;
     /** For live projection this must come from validated current claim snapshots for subjectId. */
     routeSupportedClaims?: readonly string[];
+    /** Fabric harness/platform/precondition state for task_effectiveness applicability. */
+    fabricCapability?: {
+      harnessFeatures: readonly string[];
+      platforms: readonly string[];
+      routePreconditions: readonly string[];
+    };
     loadScenarioManifest?: LoadScenarioManifest;
     loadScenarioRequirements?: LoadScenarioRequirements;
     asOf?: number;
@@ -165,6 +217,26 @@ export function evaluateAllApplicableRequiredPassV1(
       return { applicableRequiredScenarioIds: [], passingRequiredScenarioIds: [], missingRequiredScenarioIds: [], canVerify: false, notes: ["route_claim_state_required"] };
     }
   }
+  if (suiteManifest.evidenceLayer === "task_effectiveness") {
+    if (opts.subject?.subjectKind !== "task") {
+      return {
+        applicableRequiredScenarioIds: [],
+        passingRequiredScenarioIds: [],
+        missingRequiredScenarioIds: [],
+        canVerify: false,
+        notes: ["task_subject_required"],
+      };
+    }
+    if (executionMode !== "fabric") {
+      return {
+        applicableRequiredScenarioIds: [],
+        passingRequiredScenarioIds: [],
+        missingRequiredScenarioIds: [],
+        canVerify: false,
+        notes: ["fabric_execution_mode_required"],
+      };
+    }
+  }
 
   const requiredScenarios = suiteManifest.scenarios.filter(
     (s) => s.role === "required" || s.role === "negative_control",
@@ -198,6 +270,14 @@ export function evaluateAllApplicableRequiredPassV1(
     if (suiteManifest.evidenceLayer === "live_route_compatibility" && opts.subject?.subjectKind === "route") {
       if (!routeSubjectApplicableToRequirements(requirements, opts.subject, opts.routeSupportedClaims!)) continue;
     }
+    if (suiteManifest.evidenceLayer === "task_effectiveness" && opts.subject?.subjectKind === "task") {
+      const capability = opts.fabricCapability ?? {
+        harnessFeatures: ["fabric-scratch-v1"],
+        platforms: [process.platform, "*"],
+        routePreconditions: ["exact-route-subject"],
+      };
+      if (!taskSubjectApplicableToRequirements(requirements, capability)) continue;
+    }
     applicableRequired.push(s.id);
     scenarioMaxAgeById.set(s.id, requirements.freshness?.maxAgeMs ?? null);
   }

package/src/lab/query/catalog.ts

@@ -14,15 +14,31 @@ import {
 import {
   suiteManifestDigestForCase,
 } from "../conformance/suite-manifest";
+import {
+  discoverFabricScenarios,
+  expandFabricScenario,
+  fabricSuiteManifestDigest,
+  loadFabricCaseAuthority,
+} from "../fabric/manifest";
 import { scenarioManifestDigest } from "../digest";
-import type { CaseRecord } from "../conformance/types";
+import type { CaseRecord, EvidenceLayer, VerificationRole } from "../conformance/types";
 import type { CatalogFilters, CatalogScenarioDto } from "./types";
 
-function mapCaseToCatalogScenario(
+type CatalogAuthority = {
+  manifestDefaults: {
+    version: string;
+    suiteVersion: string;
+    evidenceLayer: EvidenceLayer;
+    verificationRole: VerificationRole;
+    freshness: { maxAgeMs: number | null };
+  };
+};
+
+function mapCaseToCatalogScenario<TAuthority extends CatalogAuthority>(
   caseRecord: CaseRecord,
-  authority: ReturnType<typeof loadCaseAuthority>,
-  suiteDigestFn: (caseRecord: CaseRecord, authority: ReturnType<typeof loadCaseAuthority>) => string,
-  expandFn: (caseRecord: CaseRecord, authority: ReturnType<typeof loadCaseAuthority>) => Record<string, unknown>,
+  authority: TAuthority,
+  suiteDigestFn: (caseRecord: CaseRecord, authority: TAuthority) => string,
+  expandFn: (caseRecord: CaseRecord, authority: TAuthority) => Record<string, unknown>,
 ): CatalogScenarioDto {
   const expanded = expandFn(caseRecord, authority);
   return {
@@ -62,6 +78,19 @@ export function queryLabCatalog(filters: CatalogFilters = {}): CatalogScenarioDt
       items.push(mapCaseToCatalogScenario(caseRecord, authority, liveSuiteManifestDigestForCase, expandLiveScenario));
     }
   }
+  if (!filters.layer || filters.layer === "task_effectiveness") {
+    const authority = loadFabricCaseAuthority();
+    const suites = filters.suiteId ? [filters.suiteId] : undefined;
+    const scenarios = discoverFabricScenarios(authority, suites ?? undefined);
+    for (const caseRecord of scenarios) {
+      items.push(mapCaseToCatalogScenario(
+        caseRecord,
+        authority,
+        (row, auth) => fabricSuiteManifestDigest(row.suite, auth),
+        expandFabricScenario,
+      ));
+    }
+  }
   return items.sort((a, b) => {
     const layerCmp = a.evidenceLayer.localeCompare(b.evidenceLayer);
     if (layerCmp !== 0) return layerCmp;

package/src/lab/query/freshness.ts

@@ -0,0 +1,53 @@
+import type { EvidenceLayer } from "../constants";
+import { closeLabReadConnection, openLabReadConnection } from "./connection";
+
+export interface ExactObservationIdentity {
+  subjectId: string;
+  layer: EvidenceLayer;
+  suiteId: string;
+  suiteVersion: string;
+  suiteManifestDigest: string;
+  scenarioId: string;
+  scenarioVersion: string;
+  scenarioManifestDigest: string;
+}
+
+/** Return the newest non-excluded observation for one exact evidence identity. */
+export function queryLatestExactObservationCompletedAt(
+  identity: ExactObservationIdentity,
+  configDir?: string,
+): number | undefined {
+  const conn = openLabReadConnection(configDir);
+  try {
+    const row = conn.db
+      .query(
+        `SELECT o.completed_at
+         FROM observations o
+         JOIN events e ON e.event_id = o.event_id
+         WHERE o.subject_id = ?
+           AND o.evidence_layer = ?
+           AND o.suite_id = ?
+           AND o.suite_version = ?
+           AND o.suite_manifest_digest = ?
+           AND o.scenario_id = ?
+           AND o.scenario_version = ?
+           AND o.scenario_manifest_digest = ?
+           AND e.excluded = 0
+         ORDER BY o.completed_at DESC, o.event_id DESC
+         LIMIT 1`,
+      )
+      .get(
+        identity.subjectId,
+        identity.layer,
+        identity.suiteId,
+        identity.suiteVersion,
+        identity.suiteManifestDigest,
+        identity.scenarioId,
+        identity.scenarioVersion,
+        identity.scenarioManifestDigest,
+      ) as { completed_at: number } | null;
+    return row ? Number(row.completed_at) : undefined;
+  } finally {
+    closeLabReadConnection(conn);
+  }
+}

package/src/lab/query/index.ts

@@ -31,4 +31,15 @@ export {
   queryLabArtifactByDigest,
   queryLabCatalogEntries,
 } from "./queries";
+export {
+  PASSIVE_PRODUCTION_DEFAULT_LIMIT,
+  PASSIVE_PRODUCTION_MAX_LIMIT,
+  PASSIVE_PRODUCTION_MAX_SCAN_ROWS,
+  derivePassiveProductionSignals,
+  queryPassiveProductionSignals,
+  type PassiveProductionOutcome,
+  type PassiveProductionQueryResultV1,
+  type PassiveProductionSummaryV1,
+  type PassiveRouteSignalV1,
+} from "./passive-production";
 export { sanitizePublicText } from "./dto-map";

package/src/lab/query/latest-observation.ts

@@ -0,0 +1,59 @@
+import type { EvidenceLayer } from "../constants";
+import { closeLabReadConnection, openLabReadConnection } from "./connection";
+
+export interface LatestLabObservationIdentity {
+  layer: EvidenceLayer;
+  subjectId: string;
+  suiteId: string;
+  suiteVersion: string;
+  suiteManifestDigest: string;
+  scenarioId: string;
+  scenarioVersion: string;
+  scenarioManifestDigest: string;
+}
+
+/**
+ * Return the newest non-excluded observation for one exact evidence identity.
+ *
+ * The projection schema provides a composite index for every identity predicate
+ * and the descending freshness order, so planner work is independent of unrelated
+ * observation history retained for the same subject.
+ */
+export function queryLatestLabObservation(
+  identity: LatestLabObservationIdentity,
+  configDir?: string,
+): number | undefined {
+  const conn = openLabReadConnection(configDir);
+  try {
+    const row = conn.db
+      .query(
+        `SELECT o.completed_at
+         FROM observations o
+         JOIN events e ON e.event_id = o.event_id
+         WHERE o.evidence_layer = ?
+           AND o.subject_id = ?
+           AND o.suite_id = ?
+           AND o.suite_version = ?
+           AND o.suite_manifest_digest = ?
+           AND o.scenario_id = ?
+           AND o.scenario_version = ?
+           AND o.scenario_manifest_digest = ?
+           AND e.excluded = 0
+         ORDER BY o.completed_at DESC, o.event_id DESC
+         LIMIT 1`,
+      )
+      .get(
+        identity.layer,
+        identity.subjectId,
+        identity.suiteId,
+        identity.suiteVersion,
+        identity.suiteManifestDigest,
+        identity.scenarioId,
+        identity.scenarioVersion,
+        identity.scenarioManifestDigest,
+      ) as { completed_at: number } | null;
+    return row ? Number(row.completed_at) : undefined;
+  } finally {
+    closeLabReadConnection(conn);
+  }
+}

package/src/lab/query/passive-production.ts

@@ -0,0 +1,159 @@
+import {
+  isLabRouteSubjectId,
+  readRecentUsageEntries,
+  type PersistedUsageAttempt,
+  type PersistedUsageEntry,
+} from "../../usage/log";
+
+export const PASSIVE_PRODUCTION_DEFAULT_LIMIT = 50;
+export const PASSIVE_PRODUCTION_MAX_LIMIT = 200;
+export const PASSIVE_PRODUCTION_MAX_SCAN_ROWS = 2_000;
+
+export type PassiveProductionOutcome =
+  | "success"
+  | "client_cancel"
+  | "route_error"
+  | "environmental"
+  | "unknown";
+
+export interface PassiveRouteSignalV1 {
+  schemaVersion: 1;
+  subjectId: string;
+  source: "production_usage_v1";
+  requestRef: string;
+  decisionRef?: string;
+  attemptOrdinal: number;
+  observedAt: number;
+  outcome: PassiveProductionOutcome;
+  httpStatus?: number;
+}
+
+export interface PassiveProductionSummaryV1 {
+  schemaVersion: 1;
+  subjectId: string;
+  verificationStatus: "not_verification";
+  recentProductionAttempts: number;
+  recentSuccessfulAttempts: number;
+  recentRouteErrorSignals: number;
+  lastObservedProductionAttempt?: number;
+}
+
+export interface PassiveProductionQueryResultV1 {
+  schemaVersion: 1;
+  verificationStatus: "not_verification";
+  summary: PassiveProductionSummaryV1;
+  signals: PassiveRouteSignalV1[];
+  scannedRows: number;
+  truncated: boolean;
+}
+
+const ROUTE_ERROR_CODES = new Set([
+  "upstream_error",
+  "upstream_transport_error",
+  "upstream_connect_error",
+  "upstream_timeout",
+]);
+const ENVIRONMENTAL_ERROR_CODES = new Set([
+  "authentication_error",
+  "rate_limit_error",
+  "admission_rejected",
+  "upstream_host_circuit_open",
+]);
+
+function boundedLimit(value: number | undefined): number {
+  if (value === undefined) return PASSIVE_PRODUCTION_DEFAULT_LIMIT;
+  if (!Number.isSafeInteger(value) || value < 1) throw new RangeError("passive production limit must be a positive integer");
+  return Math.min(value, PASSIVE_PRODUCTION_MAX_LIMIT);
+}
+
+function isFinalAttempt(entry: PersistedUsageEntry, attempt: PersistedUsageAttempt): boolean {
+  const attempts = entry.attempts ?? [];
+  return attempts.length > 0 && attempts[attempts.length - 1]?.ordinal === attempt.ordinal;
+}
+
+function classifyOutcome(entry: PersistedUsageEntry, attempt: PersistedUsageAttempt): PassiveProductionOutcome {
+  if (attempt.status >= 200 && attempt.status < 300) return "success";
+  if (isFinalAttempt(entry, attempt) && entry.closeReason === "client_cancel") return "client_cancel";
+  if (attempt.errorCode && ENVIRONMENTAL_ERROR_CODES.has(attempt.errorCode)) return "environmental";
+  if (attempt.errorCode && ROUTE_ERROR_CODES.has(attempt.errorCode)) return "route_error";
+  return "unknown";
+}
+
+function signalFor(entry: PersistedUsageEntry, attempt: PersistedUsageAttempt): PassiveRouteSignalV1 | null {
+  const subjectId = attempt.labRouteSubjectId;
+  if (!isLabRouteSubjectId(subjectId)) return null;
+  return {
+    schemaVersion: 1,
+    subjectId,
+    source: "production_usage_v1",
+    requestRef: entry.requestId,
+    ...(entry.routeDecision?.decisionId ? { decisionRef: entry.routeDecision.decisionId } : {}),
+    attemptOrdinal: attempt.ordinal,
+    observedAt: entry.timestamp,
+    outcome: classifyOutcome(entry, attempt),
+    httpStatus: attempt.status,
+  };
+}
+
+export function derivePassiveProductionSignals(
+  entries: readonly PersistedUsageEntry[],
+  subjectId: string,
+  limit?: number,
+): PassiveProductionQueryResultV1 {
+  if (!isLabRouteSubjectId(subjectId)) throw new Error("invalid passive production subject id");
+  const maxResults = boundedLimit(limit);
+  const signals: PassiveRouteSignalV1[] = [];
+  // readRecentUsageEntries returns the selected append-only rows oldest-first.
+  // Tail selection, reverse iteration, and signals[0] as the newest observation rely on this ordering.
+  const scanRows = entries.slice(-PASSIVE_PRODUCTION_MAX_SCAN_ROWS);
+  const scanTruncated = entries.length > PASSIVE_PRODUCTION_MAX_SCAN_ROWS;
+  let resultTruncated = false;
+
+  scan: for (let rowIndex = scanRows.length - 1; rowIndex >= 0; rowIndex--) {
+    const entry = scanRows[rowIndex]!;
+    const attempts = entry.attempts ?? [];
+    for (let attemptIndex = attempts.length - 1; attemptIndex >= 0; attemptIndex--) {
+      const signal = signalFor(entry, attempts[attemptIndex]!);
+      if (signal?.subjectId !== subjectId) continue;
+      if (signals.length >= maxResults) {
+        resultTruncated = true;
+        break scan;
+      }
+      signals.push(signal);
+    }
+  }
+
+  const recentSuccessfulAttempts = signals.filter(signal => signal.outcome === "success").length;
+  const recentRouteErrorSignals = signals.filter(signal => signal.outcome === "route_error").length;
+  return {
+    schemaVersion: 1,
+    verificationStatus: "not_verification",
+    summary: {
+      schemaVersion: 1,
+      subjectId,
+      verificationStatus: "not_verification",
+      recentProductionAttempts: signals.length,
+      recentSuccessfulAttempts,
+      recentRouteErrorSignals,
+      ...(signals[0] ? { lastObservedProductionAttempt: signals[0].observedAt } : {}),
+    },
+    signals,
+    scannedRows: scanRows.length,
+    truncated: scanTruncated || resultTruncated,
+  };
+}
+
+/** Read-only bounded CL-09 projection over the existing usage-log authority. */
+export function queryPassiveProductionSignals(
+  subjectId: string,
+  limit?: number,
+  configDir?: string,
+): PassiveProductionQueryResultV1 {
+  return derivePassiveProductionSignals(
+    // Read one row past the scan cap so the projection can distinguish an exact-cap history
+    // from a history with older rows omitted by the bounded reader.
+    readRecentUsageEntries(PASSIVE_PRODUCTION_MAX_SCAN_ROWS + 1, configDir),
+    subjectId,
+    limit,
+  );
+}