selftune 0.2.18 → 0.2.19

package/cli/selftune/routes/skill-report.ts

@@ -120,6 +120,8 @@ export function handleSkillReport(
     query: string | null;
     source: string | null;
     skill_invocation_id: string;
+    capture_mode: string | null;
+    raw_source_ref: string | null;
   }>;
 
   if (invCursor) {
@@ -128,7 +130,7 @@ export function handleSkillReport(
         `SELECT si.occurred_at as timestamp, si.session_id, si.skill_name,
                 si.invocation_mode, si.triggered, si.confidence, si.tool_name,
                 si.agent_type, COALESCE(si.query, p.prompt_text) as query, si.source,
-                si.skill_invocation_id
+                si.skill_invocation_id, si.capture_mode, si.raw_source_ref
          FROM skill_invocations si
          LEFT JOIN prompts p ON si.matched_prompt_id = p.prompt_id
          WHERE si.skill_name = ?
@@ -149,7 +151,7 @@ export function handleSkillReport(
         `SELECT si.occurred_at as timestamp, si.session_id, si.skill_name,
                 si.invocation_mode, si.triggered, si.confidence, si.tool_name,
                 si.agent_type, COALESCE(si.query, p.prompt_text) as query, si.source,
-                si.skill_invocation_id
+                si.skill_invocation_id, si.capture_mode, si.raw_source_ref
          FROM skill_invocations si
          LEFT JOIN prompts p ON si.matched_prompt_id = p.prompt_id
          WHERE si.skill_name = ?
@@ -163,11 +165,6 @@ export function handleSkillReport(
   const invPageRows = invHasMore
     ? invocationsWithConfidence.slice(0, invLimit)
     : invocationsWithConfidence;
-  const invLastRow = invPageRows[invPageRows.length - 1];
-  const invNextCursor =
-    invHasMore && invLastRow
-      ? { timestamp: invLastRow.timestamp, id: invLastRow.skill_invocation_id }
-      : null;
 
   // Not-found check — after all enrichment queries so evidence-only skills aren't 404'd
   const hasData =
@@ -286,6 +283,541 @@ export function handleSkillReport(
     ? scoreDescription(currentDescriptionText, skillName)
     : null;
 
+  // ── Trust field computation ──────────────────────────────────────────────
+
+  const SYSTEM_LIKE_PREFIXES = ["<system_instruction>", "<system-instruction>", "<command-name>"];
+  const INTERNAL_EVAL_MARKERS = [
+    "you are an evaluation assistant",
+    "you are a skill description optimizer",
+    "would each query trigger this skill",
+    "propose an improved description",
+    "failure patterns:",
+    "output only valid json",
+  ];
+  const isSystemLike = (text: string | null | undefined): boolean => {
+    if (!text) return false;
+    const trimmed = text.trimStart();
+    return SYSTEM_LIKE_PREFIXES.some((p) => trimmed.startsWith(p));
+  };
+  const isInternalSelftunePrompt = (
+    text: string | null | undefined,
+    promptKind: string | null | undefined,
+  ): boolean => {
+    if (!text) return false;
+    const lowered = text.toLowerCase();
+    return (
+      promptKind === "meta" && INTERNAL_EVAL_MARKERS.some((marker) => lowered.includes(marker))
+    );
+  };
+  const isPollutingPrompt = (
+    text: string | null | undefined,
+    promptKind: string | null | undefined,
+  ): boolean => isSystemLike(text) || isInternalSelftunePrompt(text, promptKind);
+  const classifyObservationKind = (
+    skillInvocationId: string,
+    captureMode: string | null,
+    triggered: number,
+    rawSourceRefJson: string | null,
+  ): "canonical" | "repaired_trigger" | "repaired_contextual_miss" | "legacy_materialized" => {
+    if (skillInvocationId.includes(":su:")) return "legacy_materialized";
+    if (captureMode === "repair") {
+      const rawSourceRef = safeParseJson(rawSourceRefJson) as {
+        metadata?: { miss_type?: string };
+      } | null;
+      if (triggered === 0 && rawSourceRef?.metadata?.miss_type === "contextual_read") {
+        return "repaired_contextual_miss";
+      }
+      return "repaired_trigger";
+    }
+    return "canonical";
+  };
+
+  // Fetch all invocations for this skill with joined prompt + session data
+  const allInvocations = db
+    .query(
+      `SELECT si.occurred_at AS timestamp, si.session_id, si.skill_name,
+              si.invocation_mode, si.triggered, si.confidence, si.tool_name,
+              si.agent_type, si.query AS inline_query, si.source,
+              si.matched_prompt_id, si.skill_scope, si.skill_path,
+              si.skill_invocation_id, si.capture_mode, si.raw_source_ref,
+              p.prompt_text, p.prompt_kind,
+              s.platform, s.workspace_path
+       FROM skill_invocations si
+       LEFT JOIN prompts p ON si.matched_prompt_id = p.prompt_id
+       LEFT JOIN sessions s ON si.session_id = s.session_id
+       WHERE si.skill_name = ?
+       ORDER BY si.occurred_at DESC`,
+    )
+    .all(skillName) as Array<{
+    timestamp: string | null;
+    session_id: string;
+    skill_name: string;
+    invocation_mode: string | null;
+    triggered: number;
+    confidence: number | null;
+    tool_name: string | null;
+    agent_type: string | null;
+    inline_query: string | null;
+    source: string | null;
+    matched_prompt_id: string | null;
+    skill_scope: string | null;
+    skill_path: string | null;
+    skill_invocation_id: string;
+    capture_mode: string | null;
+    raw_source_ref: string | null;
+    prompt_text: string | null;
+    prompt_kind: string | null;
+    platform: string | null;
+    workspace_path: string | null;
+  }>;
+
+  const totalInv = allInvocations.length;
+  const safeDiv = (num: number, den: number): number => (den > 0 ? num / den : 0);
+
+  // Coverage
+  const distinctSessions = new Set(allInvocations.map((r) => r.session_id));
+  const distinctWorkspaces = new Set(allInvocations.map((r) => r.workspace_path).filter(Boolean));
+  const allTimestamps = allInvocations
+    .map((r) => r.timestamp)
+    .filter((t): t is string => t != null);
+  const coverage = {
+    checks: report.usage.total_checks,
+    sessions: distinctSessions.size,
+    workspaces: distinctWorkspaces.size,
+    first_seen: allTimestamps.length > 0 ? allTimestamps[allTimestamps.length - 1] : null,
+    last_seen: allTimestamps.length > 0 ? allTimestamps[0] : null,
+  };
+
+  // Evidence quality
+  let promptLinked = 0;
+  let inlineQueryCount = 0;
+  let userPromptCount = 0;
+  let metaPromptCount = 0;
+  let internalPromptCount = 0;
+  let noPromptCount = 0;
+  let systemLikeCount = 0;
+  let invModeCount = 0;
+  let confCount = 0;
+  let sourceCount = 0;
+  let scopeCount = 0;
+
+  for (const inv of allInvocations) {
+    const queryText = inv.inline_query || inv.prompt_text || "";
+    if (inv.matched_prompt_id != null) promptLinked++;
+    if (inv.inline_query != null && inv.inline_query !== "") inlineQueryCount++;
+    if (inv.prompt_kind === "user") userPromptCount++;
+    if (inv.prompt_kind === "meta") metaPromptCount++;
+    if (isInternalSelftunePrompt(queryText, inv.prompt_kind)) internalPromptCount++;
+    if (inv.matched_prompt_id == null && (inv.inline_query == null || inv.inline_query === ""))
+      noPromptCount++;
+    if (isPollutingPrompt(queryText, inv.prompt_kind)) systemLikeCount++;
+    if (inv.invocation_mode != null && inv.invocation_mode !== "") invModeCount++;
+    if (inv.confidence != null) confCount++;
+    if (inv.source != null && inv.source !== "") sourceCount++;
+    if (inv.skill_scope != null && inv.skill_scope !== "") scopeCount++;
+  }
+
+  const evidence_quality = {
+    prompt_link_rate: safeDiv(promptLinked, totalInv),
+    inline_query_rate: safeDiv(inlineQueryCount, totalInv),
+    user_prompt_rate: safeDiv(userPromptCount, totalInv),
+    meta_prompt_rate: safeDiv(metaPromptCount, totalInv),
+    internal_prompt_rate: safeDiv(internalPromptCount, totalInv),
+    no_prompt_rate: safeDiv(noPromptCount, totalInv),
+    system_like_rate: safeDiv(systemLikeCount, totalInv),
+    invocation_mode_coverage: safeDiv(invModeCount, totalInv),
+    confidence_coverage: safeDiv(confCount, totalInv),
+    source_coverage: safeDiv(sourceCount, totalInv),
+    scope_coverage: safeDiv(scopeCount, totalInv),
+  };
+
+  // Routing quality
+  const missedTriggers = allInvocations.filter((r) => r.triggered === 0).length;
+  const withConfidence = allInvocations.filter((r) => r.confidence != null);
+  const avgConfidence =
+    withConfidence.length > 0
+      ? withConfidence.reduce((s, r) => s + (r.confidence ?? 0), 0) / withConfidence.length
+      : null;
+  const lowConfCount = withConfidence.filter((r) => (r.confidence ?? 0) < 0.5).length;
+
+  const routing_quality = {
+    missed_triggers: missedTriggers,
+    miss_rate: safeDiv(missedTriggers, totalInv),
+    avg_confidence: avgConfidence,
+    confidence_coverage: safeDiv(confCount, totalInv),
+    low_confidence_rate:
+      withConfidence.length > 0 ? safeDiv(lowConfCount, withConfidence.length) : null,
+  };
+
+  // Evolution state
+  const evidenceCountRow = db
+    .query(`SELECT COUNT(*) AS cnt FROM evolution_evidence WHERE skill_name = ?`)
+    .get(skillName) as { cnt: number } | null;
+  const evolutionCountRow = db
+    .query(
+      `SELECT COUNT(*) AS cnt FROM evolution_audit
+       WHERE skill_name = ? OR (skill_name IS NULL AND proposal_id LIKE 'evo-' || ? || '-%')`,
+    )
+    .get(skillName, skillName) as { cnt: number } | null;
+  const latestAuditRow = db
+    .query(
+      `SELECT action, timestamp FROM evolution_audit
+       WHERE (skill_name = ? OR (skill_name IS NULL AND proposal_id LIKE 'evo-' || ? || '-%'))
+         AND action IN ('deployed', 'rolled_back', 'validated', 'proposed', 'approved')
+       ORDER BY timestamp DESC LIMIT 1`,
+    )
+    .get(skillName, skillName) as { action: string; timestamp: string } | null;
+
+  const evolution_state = {
+    has_evidence: (evidenceCountRow?.cnt ?? 0) > 0,
+    has_pending_proposals: pending_proposals.length > 0,
+    latest_action: latestAuditRow?.action ?? null,
+    latest_timestamp: latestAuditRow?.timestamp ?? null,
+    evidence_rows: evidenceCountRow?.cnt ?? 0,
+    evolution_rows: evolutionCountRow?.cnt ?? 0,
+  };
+
+  // Data hygiene
+  const namingVariants = db
+    .query(`SELECT DISTINCT skill_name FROM skill_invocations WHERE lower(skill_name) = lower(?)`)
+    .all(skillName) as Array<{ skill_name: string }>;
+
+  const sourceBreakdown = db
+    .query(
+      `SELECT COALESCE(source, '(null)') AS source, COUNT(*) AS count
+       FROM skill_invocations WHERE skill_name = ?
+       GROUP BY source ORDER BY count DESC`,
+    )
+    .all(skillName) as Array<{ source: string; count: number }>;
+
+  const promptKindBreakdown = db
+    .query(
+      `SELECT COALESCE(p.prompt_kind, '(null)') AS kind, COUNT(*) AS count
+       FROM skill_invocations si
+       LEFT JOIN prompts p ON si.matched_prompt_id = p.prompt_id
+       WHERE si.skill_name = ?
+       GROUP BY p.prompt_kind ORDER BY count DESC`,
+    )
+    .all(skillName) as Array<{ kind: string; count: number }>;
+
+  const observationBreakdownMap = new Map<
+    "canonical" | "repaired_trigger" | "repaired_contextual_miss" | "legacy_materialized",
+    number
+  >();
+  const enrichedInvocations = allInvocations.map((inv) => {
+    const queryText = inv.inline_query || inv.prompt_text || "";
+    const isPolluting = isPollutingPrompt(queryText, inv.prompt_kind);
+    const observation_kind = classifyObservationKind(
+      inv.skill_invocation_id,
+      inv.capture_mode,
+      inv.triggered,
+      inv.raw_source_ref,
+    );
+    return {
+      ...inv,
+      queryText,
+      isPolluting,
+      observation_kind,
+    };
+  });
+
+  for (const inv of enrichedInvocations) {
+    observationBreakdownMap.set(
+      inv.observation_kind,
+      (observationBreakdownMap.get(inv.observation_kind) ?? 0) + 1,
+    );
+  }
+
+  const trustInvocationsRaw = enrichedInvocations.filter(
+    (inv) => inv.observation_kind !== "legacy_materialized",
+  );
+
+  const normalizeQueryForGrouping = (query: string) =>
+    query.replace(/\s+/g, " ").trim().toLowerCase();
+
+  const dedupeTrustInvocations = <T extends (typeof trustInvocationsRaw)[number]>(rows: T[]) => {
+    const grouped = new Map<string, T[]>();
+    for (const row of rows) {
+      const normalizedQuery = normalizeQueryForGrouping(row.queryText);
+      const key =
+        normalizedQuery.length > 0
+          ? `${row.session_id}::${normalizedQuery}`
+          : `${row.skill_invocation_id}`;
+      const arr = grouped.get(key);
+      if (arr) arr.push(row);
+      else grouped.set(key, [row]);
+    }
+
+    return [...grouped.values()]
+      .map((group) => {
+        const sorted = [...group].sort((a, b) => {
+          const aScore =
+            (a.triggered === 1 ? 100 : 0) +
+            (a.observation_kind === "canonical" ? 20 : 0) +
+            (a.observation_kind === "repaired_trigger" ? 15 : 0) +
+            (a.confidence != null ? 5 : 0);
+          const bScore =
+            (b.triggered === 1 ? 100 : 0) +
+            (b.observation_kind === "canonical" ? 20 : 0) +
+            (b.observation_kind === "repaired_trigger" ? 15 : 0) +
+            (b.confidence != null ? 5 : 0);
+          if (aScore !== bScore) return bScore - aScore;
+          return (b.timestamp ?? "").localeCompare(a.timestamp ?? "");
+        });
+        const primary = sorted[0]!;
+        return {
+          ...primary,
+          historical_context:
+            primary.triggered === 1 && group.some((row) => row.triggered === 0)
+              ? ("previously_missed" as const)
+              : null,
+        };
+      })
+      .sort((a, b) => (b.timestamp ?? "").localeCompare(a.timestamp ?? ""));
+  };
+
+  const trustInvocations = dedupeTrustInvocations(trustInvocationsRaw);
+
+  const trustTotalInv = trustInvocations.length;
+  const trustDistinctSessions = new Set(trustInvocations.map((r) => r.session_id));
+  const trustDistinctWorkspaces = new Set(
+    trustInvocations.map((r) => r.workspace_path).filter(Boolean),
+  );
+  const trustTimestamps = trustInvocations
+    .map((r) => r.timestamp)
+    .filter((t): t is string => t != null);
+
+  const legacyRows = enrichedInvocations.filter(
+    (inv) => inv.observation_kind === "legacy_materialized",
+  ).length;
+  const repairedRows = enrichedInvocations.filter(
+    (inv) =>
+      inv.observation_kind === "repaired_trigger" ||
+      inv.observation_kind === "repaired_contextual_miss",
+  ).length;
+
+  const data_hygiene = {
+    naming_variants: namingVariants.map((r) => r.skill_name),
+    source_breakdown: sourceBreakdown,
+    prompt_kind_breakdown: promptKindBreakdown,
+    observation_breakdown: [...observationBreakdownMap.entries()].map(([kind, count]) => ({
+      kind,
+      count,
+    })),
+    raw_checks: totalInv,
+    operational_checks: trustTotalInv,
+    internal_prompt_rows: internalPromptCount,
+    internal_prompt_rate: safeDiv(internalPromptCount, totalInv),
+    legacy_rows: legacyRows,
+    legacy_rate: safeDiv(legacyRows, totalInv),
+    repaired_rows: repairedRows,
+    repaired_rate: safeDiv(repairedRows, totalInv),
+  };
+
+  // Recompute trust-facing metrics from operational non-legacy observations.
+  const trustPromptLinked = trustInvocations.filter((inv) => inv.matched_prompt_id != null).length;
+  const trustInlineQueryCount = trustInvocations.filter(
+    (inv) => inv.inline_query != null && inv.inline_query !== "",
+  ).length;
+  const trustUserPromptCount = trustInvocations.filter((inv) => inv.prompt_kind === "user").length;
+  const trustMetaPromptCount = trustInvocations.filter((inv) => inv.prompt_kind === "meta").length;
+  const trustNoPromptCount = trustInvocations.filter(
+    (inv) => inv.matched_prompt_id == null && (inv.inline_query == null || inv.inline_query === ""),
+  ).length;
+  const trustSystemLikeCount = trustInvocations.filter((inv) => inv.isPolluting).length;
+  const trustInvModeCount = trustInvocations.filter(
+    (inv) => inv.invocation_mode != null && inv.invocation_mode !== "",
+  ).length;
+  const trustConfCount = trustInvocations.filter((inv) => inv.confidence != null).length;
+  const trustSourceCount = trustInvocations.filter(
+    (inv) => inv.source != null && inv.source !== "",
+  ).length;
+  const trustScopeCount = trustInvocations.filter(
+    (inv) => inv.skill_scope != null && inv.skill_scope !== "",
+  ).length;
+
+  coverage.checks = trustTotalInv;
+  coverage.sessions = trustDistinctSessions.size;
+  coverage.workspaces = trustDistinctWorkspaces.size;
+  coverage.first_seen =
+    trustTimestamps.length > 0 ? trustTimestamps[trustTimestamps.length - 1] : null;
+  coverage.last_seen = trustTimestamps.length > 0 ? trustTimestamps[0] : null;
+
+  evidence_quality.prompt_link_rate = safeDiv(trustPromptLinked, trustTotalInv);
+  evidence_quality.inline_query_rate = safeDiv(trustInlineQueryCount, trustTotalInv);
+  evidence_quality.user_prompt_rate = safeDiv(trustUserPromptCount, trustTotalInv);
+  evidence_quality.meta_prompt_rate = safeDiv(trustMetaPromptCount, trustTotalInv);
+  evidence_quality.no_prompt_rate = safeDiv(trustNoPromptCount, trustTotalInv);
+  evidence_quality.system_like_rate = safeDiv(trustSystemLikeCount, trustTotalInv);
+  evidence_quality.invocation_mode_coverage = safeDiv(trustInvModeCount, trustTotalInv);
+  evidence_quality.confidence_coverage = safeDiv(trustConfCount, trustTotalInv);
+  evidence_quality.source_coverage = safeDiv(trustSourceCount, trustTotalInv);
+  evidence_quality.scope_coverage = safeDiv(trustScopeCount, trustTotalInv);
+
+  const trustMissedTriggers = trustInvocations.filter((r) => r.triggered === 0).length;
+  const trustWithConfidence = trustInvocations.filter((r) => r.confidence != null);
+  const trustAvgConfidence =
+    trustWithConfidence.length > 0
+      ? trustWithConfidence.reduce((s, r) => s + (r.confidence ?? 0), 0) /
+        trustWithConfidence.length
+      : null;
+  const trustLowConfCount = trustWithConfidence.filter((r) => (r.confidence ?? 0) < 0.5).length;
+
+  routing_quality.missed_triggers = trustMissedTriggers;
+  routing_quality.miss_rate = safeDiv(trustMissedTriggers, trustTotalInv);
+  routing_quality.avg_confidence = trustAvgConfidence;
+  routing_quality.confidence_coverage = safeDiv(trustConfCount, trustTotalInv);
+  routing_quality.low_confidence_rate =
+    trustWithConfidence.length > 0 ? safeDiv(trustLowConfCount, trustWithConfidence.length) : null;
+
+  // Examples (limit 10 per category)
+  type ExampleRowInternal = {
+    timestamp: string | null;
+    session_id: string;
+    query_text: string;
+    triggered: boolean;
+    confidence: number | null;
+    invocation_mode: string | null;
+    prompt_kind: string | null;
+    source: string | null;
+    platform: string | null;
+    workspace_path: string | null;
+    query_origin: "inline_query" | "matched_prompt" | "missing";
+    is_system_like: boolean;
+    observation_kind:
+      | "canonical"
+      | "repaired_trigger"
+      | "repaired_contextual_miss"
+      | "legacy_materialized";
+    historical_context: "previously_missed" | null;
+  };
+
+  const goodExamples: ExampleRowInternal[] = [];
+  const missedExamples: ExampleRowInternal[] = [];
+  const noisyExamples: ExampleRowInternal[] = [];
+
+  for (const inv of dedupeTrustInvocations(trustInvocationsRaw)) {
+    const queryText = inv.queryText;
+    const sysLike = inv.isPolluting;
+    const queryOrigin: "inline_query" | "matched_prompt" | "missing" =
+      inv.inline_query != null && inv.inline_query !== ""
+        ? "inline_query"
+        : inv.matched_prompt_id != null
+          ? "matched_prompt"
+          : "missing";
+    const row: ExampleRowInternal = {
+      timestamp: inv.timestamp,
+      session_id: inv.session_id,
+      query_text: queryText,
+      triggered: inv.triggered === 1,
+      confidence: inv.confidence,
+      invocation_mode: inv.invocation_mode,
+      prompt_kind: inv.prompt_kind,
+      source: inv.source,
+      platform: inv.platform,
+      workspace_path: inv.workspace_path,
+      query_origin: queryOrigin,
+      is_system_like: sysLike,
+      observation_kind: inv.observation_kind,
+      historical_context: inv.historical_context,
+    };
+
+    if (inv.triggered === 0 && missedExamples.length < 10) {
+      missedExamples.push(row);
+    } else if (
+      inv.triggered === 1 &&
+      queryText !== "" &&
+      (queryOrigin === "inline_query" || inv.prompt_kind === "user" || inv.prompt_kind == null) &&
+      goodExamples.length < 10
+    ) {
+      goodExamples.push(row);
+    }
+  }
+
+  for (const inv of enrichedInvocations) {
+    if (!inv.isPolluting || noisyExamples.length >= 10) continue;
+    const queryOrigin: "inline_query" | "matched_prompt" | "missing" =
+      inv.inline_query != null && inv.inline_query !== ""
+        ? "inline_query"
+        : inv.matched_prompt_id != null
+          ? "matched_prompt"
+          : "missing";
+    noisyExamples.push({
+      timestamp: inv.timestamp,
+      session_id: inv.session_id,
+      query_text: inv.queryText,
+      triggered: inv.triggered === 1,
+      confidence: inv.confidence,
+      invocation_mode: inv.invocation_mode,
+      prompt_kind: inv.prompt_kind,
+      source: inv.source,
+      platform: inv.platform,
+      workspace_path: inv.workspace_path,
+      query_origin: queryOrigin,
+      is_system_like: true,
+      observation_kind: inv.observation_kind,
+      historical_context: null,
+    });
+  }
+
+  const examples = {
+    good: goodExamples,
+    missed: missedExamples,
+    noisy: noisyExamples,
+  };
+
+  // Trust state determination
+  type TrustStateType =
+    | "low_sample"
+    | "observed"
+    | "watch"
+    | "validated"
+    | "deployed"
+    | "rolled_back";
+  let trustState: TrustStateType;
+  let trustSummary: string;
+
+  if (coverage.checks < 5) {
+    trustState = "low_sample";
+    trustSummary = `Too few operational observations to assess trust — only ${coverage.checks} checks recorded.`;
+  } else if (latestAuditRow?.action === "rolled_back") {
+    trustState = "rolled_back";
+    trustSummary = "Recent evolution was rolled back — review evidence before re-deploying.";
+  } else if (latestAuditRow?.action === "deployed") {
+    trustState = "deployed";
+    trustSummary = `Deployed evolution; ${evolution_state.evidence_rows} evidence rows support current state.`;
+  } else if (latestAuditRow?.action === "validated" || latestAuditRow?.action === "approved") {
+    trustState = "validated";
+    trustSummary = "Validated with evidence but not yet deployed.";
+  } else if (
+    routing_quality.missed_triggers > 0 ||
+    evidence_quality.system_like_rate > 0.1 ||
+    evidence_quality.prompt_link_rate < 0.3
+  ) {
+    trustState = "watch";
+    const reasons: string[] = [];
+    if (routing_quality.missed_triggers > 0)
+      reasons.push(`${routing_quality.missed_triggers} missed triggers`);
+    if (evidence_quality.system_like_rate > 0.1)
+      reasons.push(`${(evidence_quality.system_like_rate * 100).toFixed(0)}% system-like queries`);
+    if (evidence_quality.prompt_link_rate < 0.3)
+      reasons.push(
+        `low prompt link rate (${(evidence_quality.prompt_link_rate * 100).toFixed(0)}%)`,
+      );
+    trustSummary = `Needs attention — ${reasons.join(", ")}.`;
+  } else {
+    trustState = "observed";
+    const qualityDesc =
+      evidence_quality.prompt_link_rate > 0.7
+        ? "strong"
+        : evidence_quality.prompt_link_rate > 0.4
+          ? "moderate"
+          : "sparse";
+    trustSummary = `Observed in ${coverage.sessions} sessions across ${coverage.workspaces} workspaces; evidence is ${qualityDesc}.`;
+  }
+
+  const trust = { state: trustState, summary: trustSummary };
+
   return Response.json({
     ...report,
     evolution: evolutionWithSnapshot,
@@ -294,12 +826,32 @@ export function handleSkillReport(
       total_input_tokens: executionRow?.total_input_tokens ?? 0,
       total_output_tokens: executionRow?.total_output_tokens ?? 0,
     },
-    canonical_invocations: invPageRows.map((i) => ({
-      ...i,
+    canonical_invocations: trustInvocations.slice(0, invLimit).map((i) => ({
+      timestamp: i.timestamp,
+      session_id: i.session_id,
+      skill_name: i.skill_name,
+      invocation_mode: i.invocation_mode,
       triggered: i.triggered === 1,
+      confidence: i.confidence,
+      tool_name: i.tool_name,
+      agent_type: i.agent_type,
+      query: i.queryText,
+      source: i.source,
+      skill_path: i.skill_path,
+      skill_scope: i.skill_scope,
+      observation_kind: i.observation_kind,
+      historical_context: i.historical_context,
     })),
     invocations_pagination:
-      invNextCursor || invCursor ? { next_cursor: invNextCursor, has_more: invHasMore } : undefined,
+      trustInvocations.length > invLimit
+        ? {
+            next_cursor: {
+              timestamp: trustInvocations[invLimit - 1]!.timestamp!,
+              id: trustInvocations[invLimit - 1]!.skill_invocation_id,
+            },
+            has_more: true,
+          }
+        : undefined,
     duration_stats: {
       avg_duration_ms: executionRow?.avg_duration_ms ?? 0,
       total_duration_ms: executionRow?.total_duration_ms ?? 0,
@@ -315,5 +867,12 @@ export function handleSkillReport(
     })),
     session_metadata: sessionMeta,
     description_quality: descriptionQuality,
+    trust,
+    coverage,
+    evidence_quality,
+    routing_quality,
+    evolution_state,
+    data_hygiene,
+    examples,
   });
 }