@bli-cockpit/telemetry-core 0.1.0

package/dist/ingest-dto.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { CaptureProvenanceSchema, IsoDateTimeSchema, JsonAttributeRecordSchema, NonEmptyStringSchema, } from "./common.js";
+import { LocalUserSessionReferenceSchema } from "./local-config.js";
+import { PrivacyClassificationSchema, RawEvidencePointerSchema, RedactionMetadataSchema, } from "./privacy.js";
+import { RiskFlagSchema } from "./risk-flags.js";
+import { SourceScanResultSchema } from "./source-adapter.js";
+import { ExternalTraceSinkPointerSchema, NormalizedOtelTelemetrySchema, } from "./trace-sink.js";
+import { LocalWorkContextSchema, TicketBindingCandidateSchema, } from "./work-context.js";
+export const TelemetryEventTypeSchema = z.enum([
+    "session_started",
+    "session_ended",
+    "work_context_updated",
+    "source_scan_completed",
+    "ticket_binding_detected",
+    "risk_flag_detected",
+    "review_signal_detected",
+    "pr_status_detected",
+    "command_signal_detected",
+    "otel_span_normalized",
+    "otel_log_normalized",
+]);
+export const TelemetryIngestEventDtoSchema = z
+    .object({
+    event_id: NonEmptyStringSchema,
+    event_type: TelemetryEventTypeSchema,
+    occurred_at: IsoDateTimeSchema,
+    provenance: CaptureProvenanceSchema,
+    privacy_classification: PrivacyClassificationSchema,
+    redaction: RedactionMetadataSchema,
+    redacted_summary: z.string().trim().min(1).max(4000).optional(),
+    metrics: z.record(z.string(), z.number()).default({}),
+    attributes: JsonAttributeRecordSchema.default({}),
+    ticket_binding: TicketBindingCandidateSchema.optional(),
+    risk_flags: z.array(RiskFlagSchema).default([]),
+    raw_evidence_pointers: z.array(RawEvidencePointerSchema).default([]),
+    otel: NormalizedOtelTelemetrySchema.optional(),
+    external_trace_sink_pointer: ExternalTraceSinkPointerSchema.optional(),
+})
+    .strict()
+    .superRefine((event, context) => {
+    if (event.privacy_classification !== event.redaction.privacy_classification) {
+        context.addIssue({
+            code: "custom",
+            message: "event privacy must match redaction privacy",
+            path: ["redaction", "privacy_classification"],
+        });
+    }
+});
+export const TelemetryIngestEnvelopeSchema = z
+    .object({
+    envelope_version: z.literal("telemetry-ingest.v1"),
+    generated_at: IsoDateTimeSchema,
+    collector_version: NonEmptyStringSchema,
+    session_reference: LocalUserSessionReferenceSchema,
+    work_context: LocalWorkContextSchema,
+    events: z.array(TelemetryIngestEventDtoSchema).min(1),
+    source_scan_results: z.array(SourceScanResultSchema).default([]),
+})
+    .strict();

package/dist/local-config.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+export declare const LocalCollectorConfigSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"telemetry-core.v1">;
+    dashboard_url: z.ZodString;
+    supabase_url: z.ZodOptional<z.ZodString>;
+    collector_version: z.ZodOptional<z.ZodString>;
+    device_id: z.ZodOptional<z.ZodString>;
+    device_name: z.ZodOptional<z.ZodString>;
+    claimed_owner_email: z.ZodOptional<z.ZodString>;
+    operator_id: z.ZodOptional<z.ZodString>;
+    default_repo_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    raw_evidence_upload: z.ZodDefault<z.ZodEnum<{
+        disabled: "disabled";
+        remote_short_retention_opt_in: "remote_short_retention_opt_in";
+    }>>;
+    session_file_path: z.ZodOptional<z.ZodString>;
+    state_dir_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type LocalCollectorConfig = z.infer<typeof LocalCollectorConfigSchema>;
+export declare const LocalUserSessionReferenceSchema: z.ZodObject<{
+    operator_id: z.ZodString;
+    auth_subject_id: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    team_id: z.ZodOptional<z.ZodString>;
+    device_id: z.ZodOptional<z.ZodString>;
+    device_name: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodString;
+    session_file_path: z.ZodString;
+    session_state: z.ZodEnum<{
+        unknown: "unknown";
+        missing: "missing";
+        valid: "valid";
+        expired: "expired";
+    }>;
+    auth_method: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        ambient_device_token: "ambient_device_token";
+        supabase_bearer: "supabase_bearer";
+    }>>;
+    issued_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type LocalUserSessionReference = z.infer<typeof LocalUserSessionReferenceSchema>;
+export declare const LocalCollectorSessionFileSchema: z.ZodObject<{
+    operator_id: z.ZodString;
+    auth_subject_id: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    team_id: z.ZodOptional<z.ZodString>;
+    device_name: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodString;
+    session_file_path: z.ZodString;
+    session_state: z.ZodEnum<{
+        unknown: "unknown";
+        missing: "missing";
+        valid: "valid";
+        expired: "expired";
+    }>;
+    auth_method: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        ambient_device_token: "ambient_device_token";
+        supabase_bearer: "supabase_bearer";
+    }>>;
+    issued_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    schema_version: z.ZodLiteral<"telemetry-core.v1">;
+    dashboard_url: z.ZodString;
+    device_id: z.ZodString;
+    device_token: z.ZodString;
+    token_type: z.ZodLiteral<"ambient_device_token">;
+    paired_at: z.ZodString;
+}, z.core.$strict>;
+export type LocalCollectorSessionFile = z.infer<typeof LocalCollectorSessionFileSchema>;

package/dist/local-config.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { IsoDateTimeSchema, NonEmptyStringSchema, VersionStringSchema, } from "./common.js";
+export const LocalCollectorConfigSchema = z
+    .object({
+    schema_version: z.literal("telemetry-core.v1"),
+    dashboard_url: z.string().url(),
+    supabase_url: z.string().url().optional(),
+    collector_version: VersionStringSchema.optional(),
+    device_id: NonEmptyStringSchema.optional(),
+    device_name: z.string().trim().min(1).max(120).optional(),
+    claimed_owner_email: z.string().email().optional(),
+    operator_id: NonEmptyStringSchema.optional(),
+    default_repo_paths: z.array(NonEmptyStringSchema).default([]),
+    raw_evidence_upload: z
+        .enum(["disabled", "remote_short_retention_opt_in"])
+        .default("disabled"),
+    session_file_path: NonEmptyStringSchema.optional(),
+    state_dir_path: NonEmptyStringSchema.optional(),
+})
+    .strict();
+export const LocalUserSessionReferenceSchema = z
+    .object({
+    operator_id: NonEmptyStringSchema,
+    auth_subject_id: NonEmptyStringSchema,
+    email: z.string().email().optional(),
+    team_id: NonEmptyStringSchema.optional(),
+    device_id: NonEmptyStringSchema.optional(),
+    device_name: z.string().trim().min(1).max(120).optional(),
+    session_id: NonEmptyStringSchema,
+    session_file_path: NonEmptyStringSchema,
+    session_state: z.enum(["missing", "valid", "expired", "unknown"]),
+    auth_method: z
+        .enum(["ambient_device_token", "supabase_bearer", "unknown"])
+        .optional(),
+    issued_at: IsoDateTimeSchema.optional(),
+    expires_at: IsoDateTimeSchema.optional(),
+})
+    .strict();
+export const LocalCollectorSessionFileSchema = LocalUserSessionReferenceSchema.extend({
+    schema_version: z.literal("telemetry-core.v1"),
+    dashboard_url: z.string().url(),
+    device_id: NonEmptyStringSchema,
+    device_token: NonEmptyStringSchema,
+    token_type: z.literal("ambient_device_token"),
+    paired_at: IsoDateTimeSchema,
+}).strict();

package/dist/paths.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare const RepoLocalContextPathsSchema: z.ZodObject<{
+    repo_root: z.ZodString;
+    car_root_dir: z.ZodString;
+    context_dir: z.ZodString;
+    active_context_file: z.ZodString;
+    tickets_dir: z.ZodString;
+    traces_dir: z.ZodString;
+}, z.core.$strict>;
+export type RepoLocalContextPaths = z.infer<typeof RepoLocalContextPathsSchema>;
+export declare const UserLocalCockpitPathsSchema: z.ZodObject<{
+    home_dir: z.ZodString;
+    config_dir: z.ZodString;
+    config_file: z.ZodString;
+    session_file: z.ZodString;
+    state_dir: z.ZodString;
+    spool_dir: z.ZodString;
+    cursors_dir: z.ZodString;
+}, z.core.$strict>;
+export type UserLocalCockpitPaths = z.infer<typeof UserLocalCockpitPathsSchema>;
+export declare function getRepoLocalContextPaths(repoRoot: string): RepoLocalContextPaths;
+export declare function getUserLocalCockpitPaths(homeDir: string): UserLocalCockpitPaths;

package/dist/paths.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { NonEmptyStringSchema } from "./common.js";
+export const RepoLocalContextPathsSchema = z
+    .object({
+    repo_root: NonEmptyStringSchema,
+    car_root_dir: NonEmptyStringSchema,
+    context_dir: NonEmptyStringSchema,
+    active_context_file: NonEmptyStringSchema,
+    tickets_dir: NonEmptyStringSchema,
+    traces_dir: NonEmptyStringSchema,
+})
+    .strict();
+export const UserLocalCockpitPathsSchema = z
+    .object({
+    home_dir: NonEmptyStringSchema,
+    config_dir: NonEmptyStringSchema,
+    config_file: NonEmptyStringSchema,
+    session_file: NonEmptyStringSchema,
+    state_dir: NonEmptyStringSchema,
+    spool_dir: NonEmptyStringSchema,
+    cursors_dir: NonEmptyStringSchema,
+})
+    .strict();
+export function getRepoLocalContextPaths(repoRoot) {
+    const repo_root = normalizeBasePath(repoRoot);
+    const car_root_dir = joinPath(repo_root, ".codex-autorunner");
+    const context_dir = joinPath(car_root_dir, "contextspace");
+    return {
+        repo_root,
+        car_root_dir,
+        context_dir,
+        active_context_file: joinPath(context_dir, "active_context.md"),
+        tickets_dir: joinPath(car_root_dir, "tickets"),
+        traces_dir: joinPath(car_root_dir, "traces"),
+    };
+}
+export function getUserLocalCockpitPaths(homeDir) {
+    const home_dir = normalizeBasePath(homeDir);
+    const config_dir = joinPath(home_dir, ".config", "bli-cockpit");
+    const state_dir = joinPath(home_dir, ".local", "state", "bli-cockpit");
+    return {
+        home_dir,
+        config_dir,
+        config_file: joinPath(config_dir, "config.json"),
+        session_file: joinPath(config_dir, "session.json"),
+        state_dir,
+        spool_dir: joinPath(state_dir, "spool"),
+        cursors_dir: joinPath(state_dir, "cursors"),
+    };
+}
+function normalizeBasePath(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error("path base must be a non-empty string");
+    }
+    if (/^[A-Za-z]:[\\/]?$/.test(trimmed)) {
+        return trimmed.replace(/[\\/]?$/, "\\");
+    }
+    return trimmed.replace(/[\\/]+$/, "");
+}
+function joinPath(base, ...segments) {
+    const separator = base.includes("\\") ? "\\" : "/";
+    const normalizedBase = normalizeBasePath(base);
+    const cleanSegments = segments.map((segment) => segment.replace(/^[\\/]+|[\\/]+$/g, ""));
+    return [normalizedBase, ...cleanSegments].join(separator);
+}

package/dist/privacy.d.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+export declare const PrivacyClassificationSchema: z.ZodEnum<{
+    metadata: "metadata";
+    redacted_summary: "redacted_summary";
+    local_only_raw_evidence: "local_only_raw_evidence";
+    remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+}>;
+export type PrivacyClassification = z.infer<typeof PrivacyClassificationSchema>;
+export declare const RawEvidencePrivacyClassificationSchema: z.ZodEnum<{
+    local_only_raw_evidence: "local_only_raw_evidence";
+    remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+}>;
+export type RawEvidencePrivacyClassification = z.infer<typeof RawEvidencePrivacyClassificationSchema>;
+export declare const RawEvidenceRetentionModeSchema: z.ZodEnum<{
+    local_only: "local_only";
+    remote_short_retention: "remote_short_retention";
+}>;
+export type RawEvidenceRetentionMode = z.infer<typeof RawEvidenceRetentionModeSchema>;
+export declare const RawEvidenceRetentionPolicySchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        local_only: "local_only";
+        remote_short_retention: "remote_short_retention";
+    }>;
+    privacy_classification: z.ZodEnum<{
+        local_only_raw_evidence: "local_only_raw_evidence";
+        remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+    }>;
+    remote_retention_days: z.ZodOptional<z.ZodNumber>;
+    expires_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RawEvidenceRetentionPolicy = z.infer<typeof RawEvidenceRetentionPolicySchema>;
+export declare const RawEvidencePointerSchema: z.ZodObject<{
+    raw_evidence_pointer_id: z.ZodString;
+    privacy_classification: z.ZodEnum<{
+        local_only_raw_evidence: "local_only_raw_evidence";
+        remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+    }>;
+    retention_policy: z.ZodObject<{
+        mode: z.ZodEnum<{
+            local_only: "local_only";
+            remote_short_retention: "remote_short_retention";
+        }>;
+        privacy_classification: z.ZodEnum<{
+            local_only_raw_evidence: "local_only_raw_evidence";
+            remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+        }>;
+        remote_retention_days: z.ZodOptional<z.ZodNumber>;
+        expires_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    storage_scope: z.ZodEnum<{
+        local_file: "local_file";
+        remote_object: "remote_object";
+    }>;
+    local_path: z.ZodOptional<z.ZodString>;
+    object_key: z.ZodOptional<z.ZodString>;
+    content_hash_sha256: z.ZodOptional<z.ZodString>;
+    byte_size: z.ZodOptional<z.ZodNumber>;
+    media_type: z.ZodOptional<z.ZodString>;
+    redacted_summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RawEvidencePointer = z.infer<typeof RawEvidencePointerSchema>;
+export declare const RedactionMetadataSchema: z.ZodObject<{
+    privacy_classification: z.ZodEnum<{
+        metadata: "metadata";
+        redacted_summary: "redacted_summary";
+        local_only_raw_evidence: "local_only_raw_evidence";
+        remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+    }>;
+    redaction_status: z.ZodEnum<{
+        metadata_only: "metadata_only";
+        redacted: "redacted";
+        raw_local_only: "raw_local_only";
+        raw_remote_short_retention: "raw_remote_short_retention";
+    }>;
+    redacted_fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    raw_evidence_pointer_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    content_hash_sha256: z.ZodOptional<z.ZodString>;
+    redacted_summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RedactionMetadata = z.infer<typeof RedactionMetadataSchema>;

package/dist/privacy.js

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { IsoDateTimeSchema, NonEmptyStringSchema, Sha256Schema, } from "./common.js";
+export const PrivacyClassificationSchema = z.enum([
+    "metadata",
+    "redacted_summary",
+    "local_only_raw_evidence",
+    "remote_short_retention_raw_evidence",
+]);
+export const RawEvidencePrivacyClassificationSchema = z.enum([
+    "local_only_raw_evidence",
+    "remote_short_retention_raw_evidence",
+]);
+export const RawEvidenceRetentionModeSchema = z.enum([
+    "local_only",
+    "remote_short_retention",
+]);
+export const RawEvidenceRetentionPolicySchema = z
+    .object({
+    mode: RawEvidenceRetentionModeSchema,
+    privacy_classification: RawEvidencePrivacyClassificationSchema,
+    remote_retention_days: z.number().int().min(1).max(30).optional(),
+    expires_at: IsoDateTimeSchema.optional(),
+})
+    .strict()
+    .superRefine((policy, context) => {
+    if (policy.mode === "local_only" &&
+        policy.privacy_classification !== "local_only_raw_evidence") {
+        context.addIssue({
+            code: "custom",
+            message: "local_only retention must use local_only_raw_evidence",
+            path: ["privacy_classification"],
+        });
+    }
+    if (policy.mode === "remote_short_retention" &&
+        policy.privacy_classification !== "remote_short_retention_raw_evidence") {
+        context.addIssue({
+            code: "custom",
+            message: "remote_short_retention must use remote_short_retention_raw_evidence",
+            path: ["privacy_classification"],
+        });
+    }
+    if (policy.mode === "local_only" && policy.remote_retention_days) {
+        context.addIssue({
+            code: "custom",
+            message: "local-only evidence cannot set remote_retention_days",
+            path: ["remote_retention_days"],
+        });
+    }
+    if (policy.mode === "remote_short_retention" &&
+        !policy.remote_retention_days) {
+        context.addIssue({
+            code: "custom",
+            message: "remote evidence must set remote_retention_days",
+            path: ["remote_retention_days"],
+        });
+    }
+});
+export const RawEvidencePointerSchema = z
+    .object({
+    raw_evidence_pointer_id: NonEmptyStringSchema,
+    privacy_classification: RawEvidencePrivacyClassificationSchema,
+    retention_policy: RawEvidenceRetentionPolicySchema,
+    storage_scope: z.enum(["local_file", "remote_object"]),
+    local_path: NonEmptyStringSchema.optional(),
+    object_key: NonEmptyStringSchema.optional(),
+    content_hash_sha256: Sha256Schema.optional(),
+    byte_size: z.number().int().nonnegative().optional(),
+    media_type: NonEmptyStringSchema.optional(),
+    redacted_summary: z.string().trim().min(1).max(4000).optional(),
+})
+    .strict()
+    .superRefine((pointer, context) => {
+    if (pointer.privacy_classification !==
+        pointer.retention_policy.privacy_classification) {
+        context.addIssue({
+            code: "custom",
+            message: "pointer privacy must match its retention policy",
+            path: ["retention_policy", "privacy_classification"],
+        });
+    }
+    if (pointer.storage_scope === "local_file" && !pointer.local_path) {
+        context.addIssue({
+            code: "custom",
+            message: "local evidence pointers require local_path",
+            path: ["local_path"],
+        });
+    }
+    if (pointer.storage_scope === "remote_object" && !pointer.object_key) {
+        context.addIssue({
+            code: "custom",
+            message: "remote evidence pointers require object_key",
+            path: ["object_key"],
+        });
+    }
+});
+export const RedactionMetadataSchema = z
+    .object({
+    privacy_classification: PrivacyClassificationSchema,
+    redaction_status: z.enum([
+        "metadata_only",
+        "redacted",
+        "raw_local_only",
+        "raw_remote_short_retention",
+    ]),
+    redacted_fields: z.array(NonEmptyStringSchema).default([]),
+    raw_evidence_pointer_ids: z.array(NonEmptyStringSchema).default([]),
+    content_hash_sha256: Sha256Schema.optional(),
+    redacted_summary: z.string().trim().min(1).max(4000).optional(),
+})
+    .strict();

package/dist/risk-flags.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+export declare const RiskFlagTypeSchema: z.ZodEnum<{
+    no_plan_signal_before_large_edit: "no_plan_signal_before_large_edit";
+    p1_or_p2_review_finding: "p1_or_p2_review_finding";
+    many_add_revert_loops: "many_add_revert_loops";
+    repeated_same_tool_input_shape: "repeated_same_tool_input_shape";
+    tool_call_loop: "tool_call_loop";
+    file_thrash_same_path: "file_thrash_same_path";
+    context_window_pressure: "context_window_pressure";
+    permission_denied_spike: "permission_denied_spike";
+    high_token_or_time_burn_no_pr: "high_token_or_time_burn_no_pr";
+    stuck_for_30_minutes: "stuck_for_30_minutes";
+    repeated_same_failing_command: "repeated_same_failing_command";
+    branch_ticket_mismatch: "branch_ticket_mismatch";
+    collector_stale: "collector_stale";
+}>;
+export type RiskFlagType = z.infer<typeof RiskFlagTypeSchema>;
+export declare const RiskEvidenceLabelSchema: z.ZodEnum<{
+    missing_plan_signal: "missing_plan_signal";
+    large_edit: "large_edit";
+    p1_review_finding: "p1_review_finding";
+    p2_review_finding: "p2_review_finding";
+    add_revert_loop: "add_revert_loop";
+    same_tool_input_shape: "same_tool_input_shape";
+    tool_call_loop_window: "tool_call_loop_window";
+    same_path_churn: "same_path_churn";
+    token_pressure: "token_pressure";
+    permission_denied: "permission_denied";
+    approval_denied: "approval_denied";
+    no_pr_after_work: "no_pr_after_work";
+    idle_or_stuck_duration: "idle_or_stuck_duration";
+    same_failing_command: "same_failing_command";
+    branch_ticket_disagreement: "branch_ticket_disagreement";
+    collector_last_seen_stale: "collector_last_seen_stale";
+}>;
+export type RiskEvidenceLabel = z.infer<typeof RiskEvidenceLabelSchema>;
+export declare const RiskFlagSchema: z.ZodObject<{
+    risk_flag_id: z.ZodString;
+    risk_type: z.ZodEnum<{
+        no_plan_signal_before_large_edit: "no_plan_signal_before_large_edit";
+        p1_or_p2_review_finding: "p1_or_p2_review_finding";
+        many_add_revert_loops: "many_add_revert_loops";
+        repeated_same_tool_input_shape: "repeated_same_tool_input_shape";
+        tool_call_loop: "tool_call_loop";
+        file_thrash_same_path: "file_thrash_same_path";
+        context_window_pressure: "context_window_pressure";
+        permission_denied_spike: "permission_denied_spike";
+        high_token_or_time_burn_no_pr: "high_token_or_time_burn_no_pr";
+        stuck_for_30_minutes: "stuck_for_30_minutes";
+        repeated_same_failing_command: "repeated_same_failing_command";
+        branch_ticket_mismatch: "branch_ticket_mismatch";
+        collector_stale: "collector_stale";
+    }>;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        high: "high";
+    }>;
+    observed_at: z.ZodString;
+    evidence_labels: z.ZodArray<z.ZodEnum<{
+        missing_plan_signal: "missing_plan_signal";
+        large_edit: "large_edit";
+        p1_review_finding: "p1_review_finding";
+        p2_review_finding: "p2_review_finding";
+        add_revert_loop: "add_revert_loop";
+        same_tool_input_shape: "same_tool_input_shape";
+        tool_call_loop_window: "tool_call_loop_window";
+        same_path_churn: "same_path_churn";
+        token_pressure: "token_pressure";
+        permission_denied: "permission_denied";
+        approval_denied: "approval_denied";
+        no_pr_after_work: "no_pr_after_work";
+        idle_or_stuck_duration: "idle_or_stuck_duration";
+        same_failing_command: "same_failing_command";
+        branch_ticket_disagreement: "branch_ticket_disagreement";
+        collector_last_seen_stale: "collector_last_seen_stale";
+    }>>;
+    evidence_pointer_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    provenance: z.ZodObject<{
+        capture_source: z.ZodEnum<{
+            unknown: "unknown";
+            codex_jsonl: "codex_jsonl";
+            codex_otel: "codex_otel";
+            car_state: "car_state";
+            git_state: "git_state";
+            github_state: "github_state";
+            linear_state: "linear_state";
+            mcp_local: "mcp_local";
+            claude_hooks: "claude_hooks";
+            manual_event: "manual_event";
+            collector_runtime: "collector_runtime";
+        }>;
+        capture_adapter_version: z.ZodString;
+        collector_version: z.ZodString;
+        repo: z.ZodString;
+        branch: z.ZodString;
+        operator_id: z.ZodString;
+        session_id: z.ZodString;
+        work_context_id: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RiskFlag = z.infer<typeof RiskFlagSchema>;

package/dist/risk-flags.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { CaptureProvenanceSchema, IsoDateTimeSchema, NonEmptyStringSchema, } from "./common.js";
+export const RiskFlagTypeSchema = z.enum([
+    "no_plan_signal_before_large_edit",
+    "p1_or_p2_review_finding",
+    "many_add_revert_loops",
+    "repeated_same_tool_input_shape",
+    "tool_call_loop",
+    "file_thrash_same_path",
+    "context_window_pressure",
+    "permission_denied_spike",
+    "high_token_or_time_burn_no_pr",
+    "stuck_for_30_minutes",
+    "repeated_same_failing_command",
+    "branch_ticket_mismatch",
+    "collector_stale",
+]);
+export const RiskEvidenceLabelSchema = z.enum([
+    "missing_plan_signal",
+    "large_edit",
+    "p1_review_finding",
+    "p2_review_finding",
+    "add_revert_loop",
+    "same_tool_input_shape",
+    "tool_call_loop_window",
+    "same_path_churn",
+    "token_pressure",
+    "permission_denied",
+    "approval_denied",
+    "no_pr_after_work",
+    "idle_or_stuck_duration",
+    "same_failing_command",
+    "branch_ticket_disagreement",
+    "collector_last_seen_stale",
+]);
+export const RiskFlagSchema = z
+    .object({
+    risk_flag_id: NonEmptyStringSchema,
+    risk_type: RiskFlagTypeSchema,
+    severity: z.enum(["info", "warning", "high"]),
+    observed_at: IsoDateTimeSchema,
+    evidence_labels: z.array(RiskEvidenceLabelSchema).min(1),
+    evidence_pointer_ids: z.array(NonEmptyStringSchema).default([]),
+    provenance: CaptureProvenanceSchema,
+})
+    .strict();