@bli-cockpit/telemetry-core 0.1.4 → 0.1.6

package/dist/agent-artifacts.d.ts

@@ -0,0 +1,224 @@
+import { z } from "zod";
+export declare const AGENT_IMAGE_ARTIFACT_MAX_FILE_BYTES: number;
+export declare const AGENT_IMAGE_ARTIFACT_MAX_REPORT_ITEMS = 100;
+export declare const AgentArtifactSourceSchema: z.ZodEnum<{
+    codex: "codex";
+    claude_code: "claude_code";
+}>;
+export type AgentArtifactSource = z.infer<typeof AgentArtifactSourceSchema>;
+export declare const AgentArtifactKindSchema: z.ZodEnum<{
+    screenshot: "screenshot";
+    image_attachment: "image_attachment";
+}>;
+export type AgentArtifactKind = z.infer<typeof AgentArtifactKindSchema>;
+export declare const AgentArtifactCaptureOriginSchema: z.ZodEnum<{
+    agent_session_attachment: "agent_session_attachment";
+}>;
+export type AgentArtifactCaptureOrigin = z.infer<typeof AgentArtifactCaptureOriginSchema>;
+export declare const AgentArtifactRedactionStatusSchema: z.ZodEnum<{
+    not_started: "not_started";
+    pending: "pending";
+    redacted: "redacted";
+    safe_for_metadata: "safe_for_metadata";
+    blocked: "blocked";
+}>;
+export type AgentArtifactRedactionStatus = z.infer<typeof AgentArtifactRedactionStatusSchema>;
+export declare const AgentArtifactOcrStatusSchema: z.ZodEnum<{
+    not_started: "not_started";
+    pending: "pending";
+    completed: "completed";
+    failed: "failed";
+    skipped: "skipped";
+}>;
+export type AgentArtifactOcrStatus = z.infer<typeof AgentArtifactOcrStatusSchema>;
+export declare const AgentImageArtifactMediaTypeSchema: z.ZodEnum<{
+    "image/png": "image/png";
+    "image/jpeg": "image/jpeg";
+}>;
+export type AgentImageArtifactMediaType = z.infer<typeof AgentImageArtifactMediaTypeSchema>;
+export declare const AgentImageArtifactStorageBucketSchema: z.ZodLiteral<"ambient-raw-evidence">;
+export type AgentImageArtifactStorageBucket = z.infer<typeof AgentImageArtifactStorageBucketSchema>;
+export declare const AgentImageArtifactStorageMetadataSchema: z.ZodObject<{
+    storage_bucket: z.ZodLiteral<"ambient-raw-evidence">;
+    object_key: z.ZodString;
+    content_hash_sha256: z.ZodString;
+    byte_size: z.ZodNumber;
+    media_type: z.ZodEnum<{
+        "image/png": "image/png";
+        "image/jpeg": "image/jpeg";
+    }>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    perceptual_hash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AgentImageArtifactStorageMetadata = z.infer<typeof AgentImageArtifactStorageMetadataSchema>;
+export declare const AgentImageArtifactBindingSchema: z.ZodObject<{
+    operator_user_id: z.ZodOptional<z.ZodString>;
+    team_id: z.ZodOptional<z.ZodString>;
+    work_session_id: z.ZodOptional<z.ZodString>;
+    task_id: z.ZodOptional<z.ZodString>;
+    ticket_id: z.ZodOptional<z.ZodString>;
+    repo_fingerprint: z.ZodOptional<z.ZodString>;
+    worktree_fingerprint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AgentImageArtifactBinding = z.infer<typeof AgentImageArtifactBindingSchema>;
+export declare const AgentImageArtifactSchema: z.ZodObject<{
+    storage_bucket: z.ZodLiteral<"ambient-raw-evidence">;
+    object_key: z.ZodString;
+    content_hash_sha256: z.ZodString;
+    byte_size: z.ZodNumber;
+    media_type: z.ZodEnum<{
+        "image/png": "image/png";
+        "image/jpeg": "image/jpeg";
+    }>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    perceptual_hash: z.ZodOptional<z.ZodString>;
+    operator_user_id: z.ZodOptional<z.ZodString>;
+    team_id: z.ZodOptional<z.ZodString>;
+    work_session_id: z.ZodOptional<z.ZodString>;
+    task_id: z.ZodOptional<z.ZodString>;
+    ticket_id: z.ZodOptional<z.ZodString>;
+    repo_fingerprint: z.ZodOptional<z.ZodString>;
+    worktree_fingerprint: z.ZodOptional<z.ZodString>;
+    artifact_id: z.ZodOptional<z.ZodString>;
+    raw_evidence_pointer_id: z.ZodString;
+    agent_source: z.ZodEnum<{
+        codex: "codex";
+        claude_code: "claude_code";
+    }>;
+    source_session_id: z.ZodString;
+    source_message_id: z.ZodOptional<z.ZodString>;
+    turn_index: z.ZodOptional<z.ZodNumber>;
+    occurred_at: z.ZodString;
+    artifact_kind: z.ZodDefault<z.ZodEnum<{
+        screenshot: "screenshot";
+        image_attachment: "image_attachment";
+    }>>;
+    capture_origin: z.ZodDefault<z.ZodEnum<{
+        agent_session_attachment: "agent_session_attachment";
+    }>>;
+    redaction_status: z.ZodDefault<z.ZodEnum<{
+        not_started: "not_started";
+        pending: "pending";
+        redacted: "redacted";
+        safe_for_metadata: "safe_for_metadata";
+        blocked: "blocked";
+    }>>;
+    ocr_status: z.ZodDefault<z.ZodEnum<{
+        not_started: "not_started";
+        pending: "pending";
+        completed: "completed";
+        failed: "failed";
+        skipped: "skipped";
+    }>>;
+    ocr_text_redacted: z.ZodOptional<z.ZodString>;
+    labels: z.ZodDefault<z.ZodObject<{
+        attachment_role: z.ZodOptional<z.ZodString>;
+        collector_upload_state: z.ZodOptional<z.ZodEnum<{
+            uploaded: "uploaded";
+            reused_existing: "reused_existing";
+        }>>;
+        source_sidecar_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentImageArtifact = z.infer<typeof AgentImageArtifactSchema>;
+export declare const AgentImageArtifactReportRequestSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"ambient-agent-image-artifacts.v1">;
+    generated_at: 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_jsonl: "claude_jsonl";
+            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;
+        repo_label: z.ZodOptional<z.ZodString>;
+        repo_fingerprint: z.ZodOptional<z.ZodString>;
+        repo_origin_url: z.ZodOptional<z.ZodString>;
+        worktree_label: z.ZodOptional<z.ZodString>;
+        worktree_fingerprint: z.ZodOptional<z.ZodString>;
+        worktree_is_primary: z.ZodOptional<z.ZodBoolean>;
+        operator_id: z.ZodString;
+        session_id: z.ZodString;
+        work_context_id: z.ZodString;
+    }, z.core.$strict>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        storage_bucket: z.ZodLiteral<"ambient-raw-evidence">;
+        object_key: z.ZodString;
+        content_hash_sha256: z.ZodString;
+        byte_size: z.ZodNumber;
+        media_type: z.ZodEnum<{
+            "image/png": "image/png";
+            "image/jpeg": "image/jpeg";
+        }>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        perceptual_hash: z.ZodOptional<z.ZodString>;
+        operator_user_id: z.ZodOptional<z.ZodString>;
+        team_id: z.ZodOptional<z.ZodString>;
+        work_session_id: z.ZodOptional<z.ZodString>;
+        task_id: z.ZodOptional<z.ZodString>;
+        ticket_id: z.ZodOptional<z.ZodString>;
+        repo_fingerprint: z.ZodOptional<z.ZodString>;
+        worktree_fingerprint: z.ZodOptional<z.ZodString>;
+        artifact_id: z.ZodOptional<z.ZodString>;
+        raw_evidence_pointer_id: z.ZodString;
+        agent_source: z.ZodEnum<{
+            codex: "codex";
+            claude_code: "claude_code";
+        }>;
+        source_session_id: z.ZodString;
+        source_message_id: z.ZodOptional<z.ZodString>;
+        turn_index: z.ZodOptional<z.ZodNumber>;
+        occurred_at: z.ZodString;
+        artifact_kind: z.ZodDefault<z.ZodEnum<{
+            screenshot: "screenshot";
+            image_attachment: "image_attachment";
+        }>>;
+        capture_origin: z.ZodDefault<z.ZodEnum<{
+            agent_session_attachment: "agent_session_attachment";
+        }>>;
+        redaction_status: z.ZodDefault<z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            redacted: "redacted";
+            safe_for_metadata: "safe_for_metadata";
+            blocked: "blocked";
+        }>>;
+        ocr_status: z.ZodDefault<z.ZodEnum<{
+            not_started: "not_started";
+            pending: "pending";
+            completed: "completed";
+            failed: "failed";
+            skipped: "skipped";
+        }>>;
+        ocr_text_redacted: z.ZodOptional<z.ZodString>;
+        labels: z.ZodDefault<z.ZodObject<{
+            attachment_role: z.ZodOptional<z.ZodString>;
+            collector_upload_state: z.ZodOptional<z.ZodEnum<{
+                uploaded: "uploaded";
+                reused_existing: "reused_existing";
+            }>>;
+            source_sidecar_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentImageArtifactReportRequest = z.infer<typeof AgentImageArtifactReportRequestSchema>;
+export declare const AgentImageArtifactReportResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    recorded_count: z.ZodNumber;
+}, z.core.$strict>;
+export type AgentImageArtifactReportResponse = z.infer<typeof AgentImageArtifactReportResponseSchema>;

package/dist/agent-artifacts.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import { CaptureProvenanceSchema, IsoDateTimeSchema, NonEmptyStringSchema, Sha256Schema, } from "./common.js";
+export const AGENT_IMAGE_ARTIFACT_MAX_FILE_BYTES = 10 * 1024 * 1024;
+export const AGENT_IMAGE_ARTIFACT_MAX_REPORT_ITEMS = 100;
+const UuidSchema = z.string().uuid();
+export const AgentArtifactSourceSchema = z.enum(["codex", "claude_code"]);
+export const AgentArtifactKindSchema = z.enum([
+    "screenshot",
+    "image_attachment",
+]);
+export const AgentArtifactCaptureOriginSchema = z.enum([
+    "agent_session_attachment",
+]);
+export const AgentArtifactRedactionStatusSchema = z.enum([
+    "not_started",
+    "pending",
+    "redacted",
+    "safe_for_metadata",
+    "blocked",
+]);
+export const AgentArtifactOcrStatusSchema = z.enum([
+    "not_started",
+    "pending",
+    "completed",
+    "failed",
+    "skipped",
+]);
+export const AgentImageArtifactMediaTypeSchema = z.enum([
+    "image/png",
+    "image/jpeg",
+]);
+export const AgentImageArtifactStorageBucketSchema = z.literal("ambient-raw-evidence");
+const AgentImageArtifactLabelsSchema = z
+    .object({
+    attachment_role: NonEmptyStringSchema.max(160).optional(),
+    collector_upload_state: z
+        .enum(["uploaded", "reused_existing"])
+        .optional(),
+    source_sidecar_id: NonEmptyStringSchema.max(160).optional(),
+})
+    .strict();
+const AgentImageArtifactStorageMetadataShape = {
+    storage_bucket: AgentImageArtifactStorageBucketSchema,
+    object_key: NonEmptyStringSchema,
+    content_hash_sha256: Sha256Schema,
+    byte_size: z
+        .number()
+        .int()
+        .positive()
+        .max(AGENT_IMAGE_ARTIFACT_MAX_FILE_BYTES),
+    media_type: AgentImageArtifactMediaTypeSchema,
+    width: z.number().int().positive().optional(),
+    height: z.number().int().positive().optional(),
+    perceptual_hash: NonEmptyStringSchema.optional(),
+};
+export const AgentImageArtifactStorageMetadataSchema = z
+    .object(AgentImageArtifactStorageMetadataShape)
+    .strict()
+    .superRefine((metadata, context) => {
+    if ((metadata.width === undefined && metadata.height !== undefined) ||
+        (metadata.width !== undefined && metadata.height === undefined)) {
+        context.addIssue({
+            code: "custom",
+            message: "image dimensions must include both width and height",
+            path: metadata.width === undefined ? ["width"] : ["height"],
+        });
+    }
+});
+const AgentImageArtifactBindingShape = {
+    operator_user_id: UuidSchema.optional(),
+    team_id: UuidSchema.optional(),
+    work_session_id: UuidSchema.optional(),
+    task_id: UuidSchema.optional(),
+    ticket_id: NonEmptyStringSchema.max(80).optional(),
+    repo_fingerprint: NonEmptyStringSchema.max(160).optional(),
+    worktree_fingerprint: NonEmptyStringSchema.max(160).optional(),
+};
+export const AgentImageArtifactBindingSchema = z
+    .object(AgentImageArtifactBindingShape)
+    .strict();
+export const AgentImageArtifactSchema = z
+    .object({
+    artifact_id: UuidSchema.optional(),
+    raw_evidence_pointer_id: NonEmptyStringSchema,
+    agent_source: AgentArtifactSourceSchema,
+    source_session_id: NonEmptyStringSchema.max(160),
+    source_message_id: NonEmptyStringSchema.max(240).optional(),
+    turn_index: z.number().int().nonnegative().optional(),
+    occurred_at: IsoDateTimeSchema,
+    artifact_kind: AgentArtifactKindSchema.default("image_attachment"),
+    capture_origin: AgentArtifactCaptureOriginSchema.default("agent_session_attachment"),
+    redaction_status: AgentArtifactRedactionStatusSchema.default("not_started"),
+    ocr_status: AgentArtifactOcrStatusSchema.default("not_started"),
+    ocr_text_redacted: z.string().trim().min(1).max(50000).optional(),
+    labels: AgentImageArtifactLabelsSchema.default({}),
+    ...AgentImageArtifactBindingShape,
+    ...AgentImageArtifactStorageMetadataShape,
+})
+    .strict()
+    .superRefine((artifact, context) => {
+    if ((artifact.width === undefined && artifact.height !== undefined) ||
+        (artifact.width !== undefined && artifact.height === undefined)) {
+        context.addIssue({
+            code: "custom",
+            message: "image dimensions must include both width and height",
+            path: artifact.width === undefined ? ["width"] : ["height"],
+        });
+    }
+    if (artifact.ocr_text_redacted && artifact.ocr_status !== "completed") {
+        context.addIssue({
+            code: "custom",
+            message: "redacted OCR text requires completed OCR status",
+            path: ["ocr_status"],
+        });
+    }
+    if (artifact.ocr_text_redacted &&
+        !["redacted", "safe_for_metadata"].includes(artifact.redaction_status)) {
+        context.addIssue({
+            code: "custom",
+            message: "redacted OCR text requires redacted metadata status",
+            path: ["redaction_status"],
+        });
+    }
+});
+export const AgentImageArtifactReportRequestSchema = z
+    .object({
+    schema_version: z.literal("ambient-agent-image-artifacts.v1"),
+    generated_at: IsoDateTimeSchema,
+    provenance: CaptureProvenanceSchema,
+    artifacts: z
+        .array(AgentImageArtifactSchema)
+        .min(1)
+        .max(AGENT_IMAGE_ARTIFACT_MAX_REPORT_ITEMS),
+})
+    .strict();
+export const AgentImageArtifactReportResponseSchema = z
+    .object({
+    ok: z.literal(true),
+    recorded_count: z.number().int().nonnegative(),
+})
+    .strict();

package/dist/evidence-completeness.d.ts

@@ -0,0 +1,106 @@
+import { z } from "zod";
+export declare const EvidenceCompletenessStatusSchema: z.ZodEnum<{
+    unknown: "unknown";
+    failed: "failed";
+    complete: "complete";
+    partial: "partial";
+    empty: "empty";
+}>;
+export type EvidenceCompletenessStatus = z.infer<typeof EvidenceCompletenessStatusSchema>;
+export declare const EvidenceCompletenessSourceCountSchema: z.ZodObject<{
+    source: z.ZodString;
+    scanned_count: z.ZodNumber;
+    included_count: z.ZodNumber;
+    skipped_count: z.ZodNumber;
+    truncated_count: z.ZodNumber;
+    deferred_count: z.ZodNumber;
+    reused_count: z.ZodNumber;
+}, z.core.$strict>;
+export type EvidenceCompletenessSourceCount = z.infer<typeof EvidenceCompletenessSourceCountSchema>;
+export declare const EvidenceCompletenessTotalsSchema: z.ZodObject<{
+    scanned_count: z.ZodNumber;
+    included_count: z.ZodNumber;
+    skipped_count: z.ZodNumber;
+    truncated_count: z.ZodNumber;
+    deferred_count: z.ZodNumber;
+    reused_count: z.ZodNumber;
+}, z.core.$strict>;
+export type EvidenceCompletenessTotals = z.infer<typeof EvidenceCompletenessTotalsSchema>;
+export declare const EvidenceCompletenessCapSchema: z.ZodObject<{
+    source: z.ZodString;
+    cap_type: z.ZodString;
+    limit: z.ZodNumber;
+    observed: z.ZodOptional<z.ZodNumber>;
+    applied: z.ZodBoolean;
+}, z.core.$strict>;
+export type EvidenceCompletenessCap = z.infer<typeof EvidenceCompletenessCapSchema>;
+export declare const EvidenceCompletenessSkipReasonSchema: z.ZodObject<{
+    source: z.ZodString;
+    reason: z.ZodString;
+    count: z.ZodNumber;
+}, z.core.$strict>;
+export type EvidenceCompletenessSkipReason = z.infer<typeof EvidenceCompletenessSkipReasonSchema>;
+export declare const EvidenceCompletenessTruncationMarkerSchema: z.ZodObject<{
+    source: z.ZodString;
+    reason: z.ZodString;
+    count: z.ZodNumber;
+    max_bytes: z.ZodOptional<z.ZodNumber>;
+    observed_bytes: z.ZodOptional<z.ZodNumber>;
+    included_bytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type EvidenceCompletenessTruncationMarker = z.infer<typeof EvidenceCompletenessTruncationMarkerSchema>;
+export declare const EvidenceCompletenessPayloadSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"evidence-completeness.v1">;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        failed: "failed";
+        complete: "complete";
+        partial: "partial";
+        empty: "empty";
+    }>;
+    generated_at: z.ZodString;
+    scan_window: z.ZodObject<{
+        started_at: z.ZodString;
+        finished_at: z.ZodString;
+        since_minutes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    source_counts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        scanned_count: z.ZodNumber;
+        included_count: z.ZodNumber;
+        skipped_count: z.ZodNumber;
+        truncated_count: z.ZodNumber;
+        deferred_count: z.ZodNumber;
+        reused_count: z.ZodNumber;
+    }, z.core.$strict>>>;
+    totals: z.ZodObject<{
+        scanned_count: z.ZodNumber;
+        included_count: z.ZodNumber;
+        skipped_count: z.ZodNumber;
+        truncated_count: z.ZodNumber;
+        deferred_count: z.ZodNumber;
+        reused_count: z.ZodNumber;
+    }, z.core.$strict>;
+    caps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        cap_type: z.ZodString;
+        limit: z.ZodNumber;
+        observed: z.ZodOptional<z.ZodNumber>;
+        applied: z.ZodBoolean;
+    }, z.core.$strict>>>;
+    skip_reasons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        reason: z.ZodString;
+        count: z.ZodNumber;
+    }, z.core.$strict>>>;
+    truncation_markers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        reason: z.ZodString;
+        count: z.ZodNumber;
+        max_bytes: z.ZodOptional<z.ZodNumber>;
+        observed_bytes: z.ZodOptional<z.ZodNumber>;
+        included_bytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type EvidenceCompletenessPayload = z.infer<typeof EvidenceCompletenessPayloadSchema>;

package/dist/evidence-completeness.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { IsoDateTimeSchema, NonEmptyStringSchema } from "./common.js";
+const EvidenceCountSchema = z.number().int().nonnegative();
+export const EvidenceCompletenessStatusSchema = z.enum([
+    "complete",
+    "partial",
+    "empty",
+    "failed",
+    "unknown",
+]);
+export const EvidenceCompletenessSourceCountSchema = z
+    .object({
+    source: NonEmptyStringSchema,
+    scanned_count: EvidenceCountSchema,
+    included_count: EvidenceCountSchema,
+    skipped_count: EvidenceCountSchema,
+    truncated_count: EvidenceCountSchema,
+    deferred_count: EvidenceCountSchema,
+    reused_count: EvidenceCountSchema,
+})
+    .strict();
+export const EvidenceCompletenessTotalsSchema = EvidenceCompletenessSourceCountSchema.omit({ source: true }).strict();
+export const EvidenceCompletenessCapSchema = z
+    .object({
+    source: NonEmptyStringSchema,
+    cap_type: NonEmptyStringSchema,
+    limit: EvidenceCountSchema,
+    observed: EvidenceCountSchema.optional(),
+    applied: z.boolean(),
+})
+    .strict();
+export const EvidenceCompletenessSkipReasonSchema = z
+    .object({
+    source: NonEmptyStringSchema,
+    reason: NonEmptyStringSchema,
+    count: EvidenceCountSchema,
+})
+    .strict();
+export const EvidenceCompletenessTruncationMarkerSchema = z
+    .object({
+    source: NonEmptyStringSchema,
+    reason: NonEmptyStringSchema,
+    count: EvidenceCountSchema,
+    max_bytes: EvidenceCountSchema.optional(),
+    observed_bytes: EvidenceCountSchema.optional(),
+    included_bytes: EvidenceCountSchema.optional(),
+})
+    .strict();
+export const EvidenceCompletenessPayloadSchema = z
+    .object({
+    schema_version: z.literal("evidence-completeness.v1"),
+    status: EvidenceCompletenessStatusSchema,
+    generated_at: IsoDateTimeSchema,
+    scan_window: z
+        .object({
+        started_at: IsoDateTimeSchema,
+        finished_at: IsoDateTimeSchema,
+        since_minutes: EvidenceCountSchema.optional(),
+    })
+        .strict(),
+    source_counts: z.array(EvidenceCompletenessSourceCountSchema).default([]),
+    totals: EvidenceCompletenessTotalsSchema,
+    caps: z.array(EvidenceCompletenessCapSchema).default([]),
+    skip_reasons: z.array(EvidenceCompletenessSkipReasonSchema).default([]),
+    truncation_markers: z
+        .array(EvidenceCompletenessTruncationMarkerSchema)
+        .default([]),
+    notes: z.array(NonEmptyStringSchema.max(160)).default([]),
+})
+    .strict();

package/dist/evidence-upload.d.ts

@@ -265,10 +265,10 @@ export type RawEvidenceUploadCommitResponse = z.infer<typeof RawEvidenceUploadCo
  * pack or silently dropped. No content-bearing fields are allowed.
  */
 export declare const CodexSessionAttributionStateSchema: z.ZodEnum<{
+    skipped: "skipped";
     attributed: "attributed";
     ambiguous: "ambiguous";
     unattributed: "unattributed";
-    skipped: "skipped";
 }>;
 export type CodexSessionAttributionState = z.infer<typeof CodexSessionAttributionStateSchema>;
 export declare const CodexSessionUploadStateSchema: z.ZodEnum<{
@@ -297,10 +297,10 @@ export declare const CodexSessionAttributionSchema: z.ZodObject<{
     }>>;
     observed_at: z.ZodString;
     attribution_state: z.ZodEnum<{
+        skipped: "skipped";
         attributed: "attributed";
         ambiguous: "ambiguous";
         unattributed: "unattributed";
-        skipped: "skipped";
     }>;
     attribution_reason: z.ZodString;
     attribution_score: z.ZodOptional<z.ZodNumber>;
@@ -364,10 +364,10 @@ export declare const CodexSessionAttributionReportRequestSchema: z.ZodObject<{
         }>>;
         observed_at: z.ZodString;
         attribution_state: z.ZodEnum<{
+            skipped: "skipped";
             attributed: "attributed";
             ambiguous: "ambiguous";
             unattributed: "unattributed";
-            skipped: "skipped";
         }>;
         attribution_reason: z.ZodString;
         attribution_score: z.ZodOptional<z.ZodNumber>;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
+export * from "./agent-artifacts.js";
 export * from "./common.js";
+export * from "./evidence-completeness.js";
 export * from "./evidence-upload.js";
 export * from "./ingest-dto.js";
 export * from "./local-config.js";

package/dist/index.js

@@ -1,4 +1,6 @@
+export * from "./agent-artifacts.js";
 export * from "./common.js";
+export * from "./evidence-completeness.js";
 export * from "./evidence-upload.js";
 export * from "./ingest-dto.js";
 export * from "./local-config.js";

package/dist/ingest-dto.d.ts

@@ -74,8 +74,8 @@ export declare const TelemetryIngestEventDtoSchema: z.ZodObject<{
             remote_durable_raw_evidence: "remote_durable_raw_evidence";
         }>;
         redaction_status: z.ZodEnum<{
-            metadata_only: "metadata_only";
             redacted: "redacted";
+            metadata_only: "metadata_only";
             raw_local_only: "raw_local_only";
             raw_remote_short_retention: "raw_remote_short_retention";
             raw_remote_durable: "raw_remote_durable";
@@ -88,6 +88,60 @@ export declare const TelemetryIngestEventDtoSchema: z.ZodObject<{
     redacted_summary: z.ZodOptional<z.ZodString>;
     metrics: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+    evidence_completeness: z.ZodOptional<z.ZodObject<{
+        schema_version: z.ZodLiteral<"evidence-completeness.v1">;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            failed: "failed";
+            complete: "complete";
+            partial: "partial";
+            empty: "empty";
+        }>;
+        generated_at: z.ZodString;
+        scan_window: z.ZodObject<{
+            started_at: z.ZodString;
+            finished_at: z.ZodString;
+            since_minutes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        source_counts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            scanned_count: z.ZodNumber;
+            included_count: z.ZodNumber;
+            skipped_count: z.ZodNumber;
+            truncated_count: z.ZodNumber;
+            deferred_count: z.ZodNumber;
+            reused_count: z.ZodNumber;
+        }, z.core.$strict>>>;
+        totals: z.ZodObject<{
+            scanned_count: z.ZodNumber;
+            included_count: z.ZodNumber;
+            skipped_count: z.ZodNumber;
+            truncated_count: z.ZodNumber;
+            deferred_count: z.ZodNumber;
+            reused_count: z.ZodNumber;
+        }, z.core.$strict>;
+        caps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            cap_type: z.ZodString;
+            limit: z.ZodNumber;
+            observed: z.ZodOptional<z.ZodNumber>;
+            applied: z.ZodBoolean;
+        }, z.core.$strict>>>;
+        skip_reasons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            count: z.ZodNumber;
+        }, z.core.$strict>>>;
+        truncation_markers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            reason: z.ZodString;
+            count: z.ZodNumber;
+            max_bytes: z.ZodOptional<z.ZodNumber>;
+            observed_bytes: z.ZodOptional<z.ZodNumber>;
+            included_bytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
     ticket_binding: z.ZodOptional<z.ZodObject<{
         ticket_id: z.ZodString;
         binding_source: z.ZodEnum<{
@@ -305,6 +359,50 @@ export declare const TelemetryIngestEnvelopeSchema: z.ZodObject<{
             evidence_labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
             external_url: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
+        topic_label: z.ZodOptional<z.ZodString>;
+        topic_summary_redacted: z.ZodOptional<z.ZodString>;
+        work_intent: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            implementation: "implementation";
+            bug_fix: "bug_fix";
+            root_cause_analysis: "root_cause_analysis";
+            planning: "planning";
+            discovery: "discovery";
+            review: "review";
+            testing: "testing";
+            documentation: "documentation";
+            release: "release";
+            learning: "learning";
+            coordination: "coordination";
+            maintenance: "maintenance";
+            analysis: "analysis";
+            other: "other";
+        }>>;
+        work_phase: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            implementation: "implementation";
+            planning: "planning";
+            discovery: "discovery";
+            review: "review";
+            testing: "testing";
+            documentation: "documentation";
+            release: "release";
+            analysis: "analysis";
+            other: "other";
+            debugging: "debugging";
+            handoff: "handoff";
+        }>>;
+        intent_source: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            explicit_user: "explicit_user";
+            linear_ticket: "linear_ticket";
+            git_branch: "git_branch";
+            collector_heuristic: "collector_heuristic";
+            agent_heuristic: "agent_heuristic";
+            llm_inference: "llm_inference";
+            manual: "manual";
+        }>>;
+        intent_confidence: z.ZodOptional<z.ZodNumber>;
         pull_request_url: z.ZodOptional<z.ZodString>;
         provenance: z.ZodOptional<z.ZodObject<{
             capture_source: z.ZodEnum<{
@@ -397,8 +495,8 @@ export declare const TelemetryIngestEnvelopeSchema: z.ZodObject<{
                 remote_durable_raw_evidence: "remote_durable_raw_evidence";
             }>;
             redaction_status: z.ZodEnum<{
-                metadata_only: "metadata_only";
                 redacted: "redacted";
+                metadata_only: "metadata_only";
                 raw_local_only: "raw_local_only";
                 raw_remote_short_retention: "raw_remote_short_retention";
                 raw_remote_durable: "raw_remote_durable";
@@ -411,6 +509,60 @@ export declare const TelemetryIngestEnvelopeSchema: z.ZodObject<{
         redacted_summary: z.ZodOptional<z.ZodString>;
         metrics: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+        evidence_completeness: z.ZodOptional<z.ZodObject<{
+            schema_version: z.ZodLiteral<"evidence-completeness.v1">;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                failed: "failed";
+                complete: "complete";
+                partial: "partial";
+                empty: "empty";
+            }>;
+            generated_at: z.ZodString;
+            scan_window: z.ZodObject<{
+                started_at: z.ZodString;
+                finished_at: z.ZodString;
+                since_minutes: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            source_counts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                scanned_count: z.ZodNumber;
+                included_count: z.ZodNumber;
+                skipped_count: z.ZodNumber;
+                truncated_count: z.ZodNumber;
+                deferred_count: z.ZodNumber;
+                reused_count: z.ZodNumber;
+            }, z.core.$strict>>>;
+            totals: z.ZodObject<{
+                scanned_count: z.ZodNumber;
+                included_count: z.ZodNumber;
+                skipped_count: z.ZodNumber;
+                truncated_count: z.ZodNumber;
+                deferred_count: z.ZodNumber;
+                reused_count: z.ZodNumber;
+            }, z.core.$strict>;
+            caps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                cap_type: z.ZodString;
+                limit: z.ZodNumber;
+                observed: z.ZodOptional<z.ZodNumber>;
+                applied: z.ZodBoolean;
+            }, z.core.$strict>>>;
+            skip_reasons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                reason: z.ZodString;
+                count: z.ZodNumber;
+            }, z.core.$strict>>>;
+            truncation_markers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                reason: z.ZodString;
+                count: z.ZodNumber;
+                max_bytes: z.ZodOptional<z.ZodNumber>;
+                observed_bytes: z.ZodOptional<z.ZodNumber>;
+                included_bytes: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
         ticket_binding: z.ZodOptional<z.ZodObject<{
             ticket_id: z.ZodString;
             binding_source: z.ZodEnum<{
@@ -590,10 +742,10 @@ export declare const TelemetryIngestEnvelopeSchema: z.ZodObject<{
         }, z.core.$strict>;
         work_context_id: z.ZodOptional<z.ZodString>;
         status: z.ZodEnum<{
-            ok: "ok";
+            failed: "failed";
             skipped: "skipped";
+            ok: "ok";
             partial: "partial";
-            failed: "failed";
         }>;
         started_at: z.ZodString;
         finished_at: z.ZodOptional<z.ZodString>;
@@ -611,8 +763,8 @@ export declare const TelemetryIngestEnvelopeSchema: z.ZodObject<{
                     remote_durable_raw_evidence: "remote_durable_raw_evidence";
                 }>;
                 redaction_status: z.ZodEnum<{
-                    metadata_only: "metadata_only";
                     redacted: "redacted";
+                    metadata_only: "metadata_only";
                     raw_local_only: "raw_local_only";
                     raw_remote_short_retention: "raw_remote_short_retention";
                     raw_remote_durable: "raw_remote_durable";

package/dist/ingest-dto.js

@@ -5,6 +5,7 @@ import { PrivacyClassificationSchema, RawEvidencePointerSchema, RedactionMetadat
 import { RiskFlagSchema } from "./risk-flags.js";
 import { SourceScanResultSchema } from "./source-adapter.js";
 import { ExternalTraceSinkPointerSchema, NormalizedOtelTelemetrySchema, } from "./trace-sink.js";
+import { EvidenceCompletenessPayloadSchema } from "./evidence-completeness.js";
 import { LocalWorkContextSchema, TicketBindingCandidateSchema, } from "./work-context.js";
 export const TelemetryEventTypeSchema = z.enum([
     "session_started",
@@ -30,6 +31,7 @@ export const TelemetryIngestEventDtoSchema = z
     redacted_summary: z.string().trim().min(1).max(4000).optional(),
     metrics: z.record(z.string(), z.number()).default({}),
     attributes: JsonAttributeRecordSchema.default({}),
+    evidence_completeness: EvidenceCompletenessPayloadSchema.optional(),
     ticket_binding: TicketBindingCandidateSchema.optional(),
     risk_flags: z.array(RiskFlagSchema).default([]),
     raw_evidence_pointers: z.array(RawEvidencePointerSchema).default([]),

package/dist/privacy.d.ts

@@ -77,8 +77,8 @@ export declare const RedactionMetadataSchema: z.ZodObject<{
         remote_durable_raw_evidence: "remote_durable_raw_evidence";
     }>;
     redaction_status: z.ZodEnum<{
-        metadata_only: "metadata_only";
         redacted: "redacted";
+        metadata_only: "metadata_only";
         raw_local_only: "raw_local_only";
         raw_remote_short_retention: "raw_remote_short_retention";
         raw_remote_durable: "raw_remote_durable";

package/dist/source-adapter.d.ts

@@ -31,8 +31,8 @@ export declare const SourceScanEventSummarySchema: z.ZodObject<{
             remote_durable_raw_evidence: "remote_durable_raw_evidence";
         }>;
         redaction_status: z.ZodEnum<{
-            metadata_only: "metadata_only";
             redacted: "redacted";
+            metadata_only: "metadata_only";
             raw_local_only: "raw_local_only";
             raw_remote_short_retention: "raw_remote_short_retention";
             raw_remote_durable: "raw_remote_durable";
@@ -98,10 +98,10 @@ export declare const SourceScanResultSchema: z.ZodObject<{
     }, z.core.$strict>;
     work_context_id: z.ZodOptional<z.ZodString>;
     status: z.ZodEnum<{
-        ok: "ok";
+        failed: "failed";
         skipped: "skipped";
+        ok: "ok";
         partial: "partial";
-        failed: "failed";
     }>;
     started_at: z.ZodString;
     finished_at: z.ZodOptional<z.ZodString>;
@@ -119,8 +119,8 @@ export declare const SourceScanResultSchema: z.ZodObject<{
                 remote_durable_raw_evidence: "remote_durable_raw_evidence";
             }>;
             redaction_status: z.ZodEnum<{
-                metadata_only: "metadata_only";
                 redacted: "redacted";
+                metadata_only: "metadata_only";
                 raw_local_only: "raw_local_only";
                 raw_remote_short_retention: "raw_remote_short_retention";
                 raw_remote_durable: "raw_remote_durable";

package/dist/work-context.d.ts

@@ -25,6 +25,50 @@ export declare const TicketBindingCandidateSchema: z.ZodObject<{
     external_url: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type TicketBindingCandidate = z.infer<typeof TicketBindingCandidateSchema>;
+export declare const WorkIntentSchema: z.ZodEnum<{
+    unknown: "unknown";
+    implementation: "implementation";
+    bug_fix: "bug_fix";
+    root_cause_analysis: "root_cause_analysis";
+    planning: "planning";
+    discovery: "discovery";
+    review: "review";
+    testing: "testing";
+    documentation: "documentation";
+    release: "release";
+    learning: "learning";
+    coordination: "coordination";
+    maintenance: "maintenance";
+    analysis: "analysis";
+    other: "other";
+}>;
+export type WorkIntent = z.infer<typeof WorkIntentSchema>;
+export declare const WorkPhaseSchema: z.ZodEnum<{
+    unknown: "unknown";
+    implementation: "implementation";
+    planning: "planning";
+    discovery: "discovery";
+    review: "review";
+    testing: "testing";
+    documentation: "documentation";
+    release: "release";
+    analysis: "analysis";
+    other: "other";
+    debugging: "debugging";
+    handoff: "handoff";
+}>;
+export type WorkPhase = z.infer<typeof WorkPhaseSchema>;
+export declare const IntentSourceSchema: z.ZodEnum<{
+    unknown: "unknown";
+    explicit_user: "explicit_user";
+    linear_ticket: "linear_ticket";
+    git_branch: "git_branch";
+    collector_heuristic: "collector_heuristic";
+    agent_heuristic: "agent_heuristic";
+    llm_inference: "llm_inference";
+    manual: "manual";
+}>;
+export type IntentSource = z.infer<typeof IntentSourceSchema>;
 export declare const LocalWorkContextSchema: z.ZodObject<{
     work_context_id: z.ZodString;
     repo: z.ZodString;
@@ -56,6 +100,50 @@ export declare const LocalWorkContextSchema: z.ZodObject<{
         evidence_labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
         external_url: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
+    topic_label: z.ZodOptional<z.ZodString>;
+    topic_summary_redacted: z.ZodOptional<z.ZodString>;
+    work_intent: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        implementation: "implementation";
+        bug_fix: "bug_fix";
+        root_cause_analysis: "root_cause_analysis";
+        planning: "planning";
+        discovery: "discovery";
+        review: "review";
+        testing: "testing";
+        documentation: "documentation";
+        release: "release";
+        learning: "learning";
+        coordination: "coordination";
+        maintenance: "maintenance";
+        analysis: "analysis";
+        other: "other";
+    }>>;
+    work_phase: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        implementation: "implementation";
+        planning: "planning";
+        discovery: "discovery";
+        review: "review";
+        testing: "testing";
+        documentation: "documentation";
+        release: "release";
+        analysis: "analysis";
+        other: "other";
+        debugging: "debugging";
+        handoff: "handoff";
+    }>>;
+    intent_source: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        explicit_user: "explicit_user";
+        linear_ticket: "linear_ticket";
+        git_branch: "git_branch";
+        collector_heuristic: "collector_heuristic";
+        agent_heuristic: "agent_heuristic";
+        llm_inference: "llm_inference";
+        manual: "manual";
+    }>>;
+    intent_confidence: z.ZodOptional<z.ZodNumber>;
     pull_request_url: z.ZodOptional<z.ZodString>;
     provenance: z.ZodOptional<z.ZodObject<{
         capture_source: z.ZodEnum<{

package/dist/work-context.js

@@ -18,6 +18,47 @@ export const TicketBindingCandidateSchema = z
     external_url: z.string().url().optional(),
 })
     .strict();
+export const WorkIntentSchema = z.enum([
+    "implementation",
+    "bug_fix",
+    "root_cause_analysis",
+    "planning",
+    "discovery",
+    "review",
+    "testing",
+    "documentation",
+    "release",
+    "learning",
+    "coordination",
+    "maintenance",
+    "analysis",
+    "unknown",
+    "other",
+]);
+export const WorkPhaseSchema = z.enum([
+    "planning",
+    "discovery",
+    "implementation",
+    "debugging",
+    "review",
+    "testing",
+    "documentation",
+    "release",
+    "handoff",
+    "analysis",
+    "unknown",
+    "other",
+]);
+export const IntentSourceSchema = z.enum([
+    "explicit_user",
+    "linear_ticket",
+    "git_branch",
+    "collector_heuristic",
+    "agent_heuristic",
+    "llm_inference",
+    "manual",
+    "unknown",
+]);
 export const LocalWorkContextSchema = z
     .object({
     work_context_id: NonEmptyStringSchema,
@@ -38,6 +79,12 @@ export const LocalWorkContextSchema = z
     ticket_binding_candidates: z
         .array(TicketBindingCandidateSchema)
         .default([]),
+    topic_label: NonEmptyStringSchema.max(120).optional(),
+    topic_summary_redacted: z.string().trim().min(1).max(500).optional(),
+    work_intent: WorkIntentSchema.optional(),
+    work_phase: WorkPhaseSchema.optional(),
+    intent_source: IntentSourceSchema.optional(),
+    intent_confidence: z.number().min(0).max(1).optional(),
     pull_request_url: z.string().url().optional(),
     provenance: CaptureProvenanceSchema.optional(),
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/telemetry-core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",