selftune 0.2.12 → 0.2.13

package/node_modules/@selftune/telemetry-contract/src/schemas.ts

@@ -0,0 +1,197 @@
+import { z } from "zod";
+
+import {
+  CANONICAL_CAPTURE_MODES,
+  CANONICAL_COMPLETION_STATUSES,
+  CANONICAL_INVOCATION_MODES,
+  CANONICAL_PLATFORMS,
+  CANONICAL_PROMPT_KINDS,
+  CANONICAL_RECORD_KINDS,
+  CANONICAL_SCHEMA_VERSION,
+  CANONICAL_SOURCE_SESSION_KINDS,
+} from "./types.js";
+
+export const canonicalPlatformSchema = z.enum(CANONICAL_PLATFORMS);
+export const captureModeSchema = z.enum(CANONICAL_CAPTURE_MODES);
+export const sourceSessionKindSchema = z.enum(CANONICAL_SOURCE_SESSION_KINDS);
+export const promptKindSchema = z.enum(CANONICAL_PROMPT_KINDS);
+export const invocationModeSchema = z.enum(CANONICAL_INVOCATION_MODES);
+export const completionStatusSchema = z.enum(CANONICAL_COMPLETION_STATUSES);
+export const recordKindSchema = z.enum(CANONICAL_RECORD_KINDS);
+
+export const rawSourceRefSchema = z.object({
+  path: z.string().optional(),
+  line: z.number().int().nonnegative().optional(),
+  event_type: z.string().optional(),
+  raw_id: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export const canonicalRecordBaseSchema = z.object({
+  record_kind: recordKindSchema,
+  schema_version: z.literal(CANONICAL_SCHEMA_VERSION),
+  normalizer_version: z.string().min(1),
+  normalized_at: z.string().datetime(),
+  platform: canonicalPlatformSchema,
+  capture_mode: captureModeSchema,
+  raw_source_ref: rawSourceRefSchema,
+});
+
+export const canonicalSessionRecordBaseSchema = canonicalRecordBaseSchema.extend({
+  source_session_kind: sourceSessionKindSchema,
+  session_id: z.string().min(1),
+});
+
+export const CanonicalSessionRecordSchema = canonicalSessionRecordBaseSchema.extend({
+  record_kind: z.literal("session"),
+  external_session_id: z.string().optional(),
+  parent_session_id: z.string().optional(),
+  agent_id: z.string().optional(),
+  agent_type: z.string().optional(),
+  agent_cli: z.string().optional(),
+  session_key: z.string().optional(),
+  channel: z.string().optional(),
+  workspace_path: z.string().optional(),
+  repo_root: z.string().optional(),
+  repo_remote: z.string().optional(),
+  branch: z.string().optional(),
+  commit_sha: z.string().optional(),
+  permission_mode: z.string().optional(),
+  approval_policy: z.string().optional(),
+  sandbox_policy: z.string().optional(),
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  started_at: z.string().datetime().optional(),
+  ended_at: z.string().datetime().optional(),
+  completion_status: completionStatusSchema.optional(),
+  end_reason: z.string().optional(),
+});
+
+export const CanonicalPromptRecordSchema = canonicalSessionRecordBaseSchema.extend({
+  record_kind: z.literal("prompt"),
+  prompt_id: z.string().min(1),
+  occurred_at: z.string().datetime(),
+  prompt_text: z.string().min(1),
+  prompt_hash: z.string().optional(),
+  prompt_kind: promptKindSchema,
+  is_actionable: z.boolean(),
+  prompt_index: z.number().int().nonnegative().optional(),
+  parent_prompt_id: z.string().optional(),
+  source_message_id: z.string().optional(),
+});
+
+export const CanonicalSkillInvocationRecordSchema = canonicalSessionRecordBaseSchema.extend({
+  record_kind: z.literal("skill_invocation"),
+  skill_invocation_id: z.string().min(1),
+  occurred_at: z.string().datetime(),
+  matched_prompt_id: z.string().min(1).optional(),
+  skill_name: z.string().min(1),
+  skill_path: z.string().optional(),
+  skill_version_hash: z.string().optional(),
+  invocation_mode: invocationModeSchema,
+  triggered: z.boolean(),
+  confidence: z.number().min(0).max(1),
+  tool_name: z.string().optional(),
+  tool_call_id: z.string().optional(),
+  agent_type: z.string().optional(),
+});
+
+export const CanonicalExecutionFactRecordSchema = canonicalSessionRecordBaseSchema.extend({
+  record_kind: z.literal("execution_fact"),
+  execution_fact_id: z.string().min(1),
+  occurred_at: z.string().datetime(),
+  prompt_id: z.string().optional(),
+  tool_calls_json: z.record(z.string(), z.number().finite()),
+  total_tool_calls: z.number().int().nonnegative(),
+  bash_commands_redacted: z.array(z.string()).optional(),
+  assistant_turns: z.number().int().nonnegative(),
+  errors_encountered: z.number().int().nonnegative(),
+  input_tokens: z.number().int().nonnegative().optional(),
+  output_tokens: z.number().int().nonnegative().optional(),
+  duration_ms: z.number().nonnegative().optional(),
+  completion_status: completionStatusSchema.optional(),
+  end_reason: z.string().optional(),
+});
+
+export const CanonicalNormalizationRunRecordSchema = canonicalRecordBaseSchema.extend({
+  record_kind: z.literal("normalization_run"),
+  run_id: z.string().min(1),
+  run_at: z.string().datetime(),
+  raw_records_seen: z.number().int().nonnegative(),
+  canonical_records_written: z.number().int().nonnegative(),
+  repair_applied: z.boolean(),
+});
+
+export const CanonicalEvolutionEvidenceRecordSchema = z.object({
+  evidence_id: z.string().min(1),
+  skill_name: z.string().min(1),
+  proposal_id: z.string().optional(),
+  target: z.string().min(1),
+  stage: z.string().min(1),
+  rationale: z.string().optional(),
+  confidence: z.number().min(0).max(1).optional(),
+  original_text: z.string().optional(),
+  proposed_text: z.string().optional(),
+  eval_set_json: z.unknown().optional(),
+  validation_json: z.unknown().optional(),
+  raw_source_ref: rawSourceRefSchema.optional(),
+});
+
+export const OrchestrateRunSkillActionSchema = z.object({
+  skill: z.string().min(1),
+  action: z.enum(["evolve", "watch", "skip"]),
+  reason: z.string(),
+  deployed: z.boolean().optional(),
+  rolledBack: z.boolean().optional(),
+  alert: z.string().nullable().optional(),
+  elapsed_ms: z.number().nonnegative().optional(),
+  llm_calls: z.number().int().nonnegative().optional(),
+});
+
+export const PushOrchestrateRunRecordSchema = z.object({
+  run_id: z.string().min(1),
+  timestamp: z.string().datetime(),
+  elapsed_ms: z.number().int().nonnegative(),
+  dry_run: z.boolean(),
+  approval_mode: z.enum(["auto", "review"]),
+  total_skills: z.number().int().nonnegative(),
+  evaluated: z.number().int().nonnegative(),
+  evolved: z.number().int().nonnegative(),
+  deployed: z.number().int().nonnegative(),
+  watched: z.number().int().nonnegative(),
+  skipped: z.number().int().nonnegative(),
+  skill_actions: z.array(OrchestrateRunSkillActionSchema),
+});
+
+export const PushPayloadV2Schema = z.object({
+  schema_version: z.literal("2.0"),
+  client_version: z.string().min(1),
+  // Queue-generated push IDs are typically UUIDs, but the wire contract only
+  // requires a stable non-empty idempotency key.
+  push_id: z.string().min(1),
+  normalizer_version: z.string().min(1),
+  canonical: z.object({
+    sessions: z.array(CanonicalSessionRecordSchema).min(0),
+    prompts: z.array(CanonicalPromptRecordSchema).min(0),
+    skill_invocations: z.array(CanonicalSkillInvocationRecordSchema).min(0),
+    execution_facts: z.array(CanonicalExecutionFactRecordSchema).min(0),
+    normalization_runs: z.array(CanonicalNormalizationRunRecordSchema).min(0),
+    evolution_evidence: z.array(CanonicalEvolutionEvidenceRecordSchema).optional(),
+    orchestrate_runs: z.array(PushOrchestrateRunRecordSchema).optional(),
+  }),
+});
+
+export type PushPayloadV2 = z.infer<typeof PushPayloadV2Schema>;
+export type ZodCanonicalSessionRecord = z.infer<typeof CanonicalSessionRecordSchema>;
+export type ZodCanonicalPromptRecord = z.infer<typeof CanonicalPromptRecordSchema>;
+export type ZodCanonicalSkillInvocationRecord = z.infer<
+  typeof CanonicalSkillInvocationRecordSchema
+>;
+export type ZodCanonicalExecutionFactRecord = z.infer<typeof CanonicalExecutionFactRecordSchema>;
+export type ZodCanonicalNormalizationRunRecord = z.infer<
+  typeof CanonicalNormalizationRunRecordSchema
+>;
+export type ZodCanonicalEvolutionEvidenceRecord = z.infer<
+  typeof CanonicalEvolutionEvidenceRecordSchema
+>;
+export type ZodPushOrchestrateRunRecord = z.infer<typeof PushOrchestrateRunRecordSchema>;

package/node_modules/@selftune/telemetry-contract/src/types.ts

@@ -0,0 +1,165 @@
+export const CANONICAL_SCHEMA_VERSION = "2.0" as const;
+export type CanonicalSchemaVersion = typeof CANONICAL_SCHEMA_VERSION;
+
+export const CANONICAL_PLATFORMS = ["claude_code", "codex", "opencode", "openclaw"] as const;
+export type CanonicalPlatform = (typeof CANONICAL_PLATFORMS)[number];
+
+export const CANONICAL_CAPTURE_MODES = [
+  "hook",
+  "replay",
+  "wrapper",
+  "batch_ingest",
+  "repair",
+] as const;
+export type CanonicalCaptureMode = (typeof CANONICAL_CAPTURE_MODES)[number];
+
+export const CANONICAL_SOURCE_SESSION_KINDS = [
+  "interactive",
+  "replayed",
+  "synthetic",
+  "repaired",
+] as const;
+export type CanonicalSourceSessionKind = (typeof CANONICAL_SOURCE_SESSION_KINDS)[number];
+
+export const CANONICAL_PROMPT_KINDS = [
+  "user",
+  "continuation",
+  "task_notification",
+  "teammate_message",
+  "system_instruction",
+  "tool_output",
+  "meta",
+  "unknown",
+] as const;
+export type CanonicalPromptKind = (typeof CANONICAL_PROMPT_KINDS)[number];
+
+export const CANONICAL_INVOCATION_MODES = ["explicit", "implicit", "inferred", "repaired"] as const;
+export type CanonicalInvocationMode = (typeof CANONICAL_INVOCATION_MODES)[number];
+
+export const CANONICAL_COMPLETION_STATUSES = [
+  "completed",
+  "failed",
+  "interrupted",
+  "cancelled",
+  "unknown",
+] as const;
+export type CanonicalCompletionStatus = (typeof CANONICAL_COMPLETION_STATUSES)[number];
+
+export const CANONICAL_RECORD_KINDS = [
+  "session",
+  "prompt",
+  "skill_invocation",
+  "execution_fact",
+  "normalization_run",
+] as const;
+export type CanonicalRecordKind = (typeof CANONICAL_RECORD_KINDS)[number];
+
+export interface CanonicalRawSourceRef {
+  path?: string;
+  line?: number;
+  event_type?: string;
+  raw_id?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CanonicalRecordBase {
+  record_kind: CanonicalRecordKind;
+  schema_version: CanonicalSchemaVersion;
+  normalizer_version: string;
+  normalized_at: string;
+  platform: CanonicalPlatform;
+  capture_mode: CanonicalCaptureMode;
+  raw_source_ref: CanonicalRawSourceRef;
+}
+
+export interface CanonicalSessionRecordBase extends CanonicalRecordBase {
+  source_session_kind: CanonicalSourceSessionKind;
+  session_id: string;
+}
+
+export interface CanonicalSessionRecord extends CanonicalSessionRecordBase {
+  record_kind: "session";
+  started_at?: string;
+  ended_at?: string;
+  external_session_id?: string;
+  parent_session_id?: string;
+  agent_id?: string;
+  agent_type?: string;
+  agent_cli?: string;
+  session_key?: string;
+  channel?: string;
+  workspace_path?: string;
+  repo_root?: string;
+  repo_remote?: string;
+  branch?: string;
+  commit_sha?: string;
+  permission_mode?: string;
+  approval_policy?: string;
+  sandbox_policy?: string;
+  provider?: string;
+  model?: string;
+  completion_status?: CanonicalCompletionStatus;
+  end_reason?: string;
+}
+
+export interface CanonicalPromptRecord extends CanonicalSessionRecordBase {
+  record_kind: "prompt";
+  prompt_id: string;
+  occurred_at: string;
+  prompt_text: string;
+  prompt_hash?: string;
+  prompt_kind: CanonicalPromptKind;
+  is_actionable: boolean;
+  prompt_index?: number;
+  parent_prompt_id?: string;
+  source_message_id?: string;
+}
+
+export interface CanonicalSkillInvocationRecord extends CanonicalSessionRecordBase {
+  record_kind: "skill_invocation";
+  skill_invocation_id: string;
+  occurred_at: string;
+  matched_prompt_id?: string;
+  skill_name: string;
+  skill_path?: string;
+  skill_version_hash?: string;
+  invocation_mode: CanonicalInvocationMode;
+  triggered: boolean;
+  confidence: number;
+  tool_name?: string;
+  tool_call_id?: string;
+  agent_type?: string;
+}
+
+export interface CanonicalExecutionFactRecord extends CanonicalSessionRecordBase {
+  record_kind: "execution_fact";
+  execution_fact_id: string;
+  occurred_at: string;
+  prompt_id?: string;
+  tool_calls_json: Record<string, number>;
+  total_tool_calls: number;
+  bash_commands_redacted?: string[];
+  assistant_turns: number;
+  errors_encountered: number;
+  input_tokens?: number;
+  output_tokens?: number;
+  duration_ms?: number;
+  completion_status?: CanonicalCompletionStatus;
+  end_reason?: string;
+}
+
+export interface CanonicalNormalizationRunRecord extends CanonicalRecordBase {
+  record_kind: "normalization_run";
+  run_id: string;
+  run_at: string;
+  raw_records_seen: number;
+  canonical_records_written: number;
+  repair_applied: boolean;
+}
+
+export type CanonicalRecord =
+  | CanonicalSessionRecord
+  | CanonicalPromptRecord
+  | CanonicalSkillInvocationRecord
+  | CanonicalExecutionFactRecord
+  | CanonicalNormalizationRunRecord;

package/node_modules/@selftune/telemetry-contract/src/validators.ts

@@ -0,0 +1,111 @@
+import {
+  CANONICAL_CAPTURE_MODES,
+  CANONICAL_COMPLETION_STATUSES,
+  CANONICAL_INVOCATION_MODES,
+  CANONICAL_PLATFORMS,
+  CANONICAL_PROMPT_KINDS,
+  CANONICAL_RECORD_KINDS,
+  CANONICAL_SCHEMA_VERSION,
+  CANONICAL_SOURCE_SESSION_KINDS,
+  type CanonicalRawSourceRef,
+  type CanonicalRecord,
+} from "./types.js";
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasString(value: Record<string, unknown>, key: string): boolean {
+  return typeof value[key] === "string" && value[key].length > 0;
+}
+
+function includesValue<T extends readonly string[]>(values: T, value: unknown): value is T[number] {
+  return typeof value === "string" && values.includes(value);
+}
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function isNumberRecord(value: unknown): value is Record<string, number> {
+  return isObject(value) && Object.values(value).every(isFiniteNumber);
+}
+
+function hasSessionScope(value: Record<string, unknown>): boolean {
+  return (
+    includesValue(CANONICAL_SOURCE_SESSION_KINDS, value.source_session_kind) &&
+    hasString(value, "session_id")
+  );
+}
+
+export function isCanonicalRawSourceRef(value: unknown): value is CanonicalRawSourceRef {
+  return isObject(value);
+}
+
+export function isCanonicalRecord(value: unknown): value is CanonicalRecord {
+  if (!isObject(value)) return false;
+  if (value.schema_version !== CANONICAL_SCHEMA_VERSION) return false;
+  if (!includesValue(CANONICAL_RECORD_KINDS, value.record_kind)) return false;
+  if (!includesValue(CANONICAL_PLATFORMS, value.platform)) return false;
+  if (!includesValue(CANONICAL_CAPTURE_MODES, value.capture_mode)) return false;
+  if (!hasString(value, "normalizer_version")) return false;
+  if (!hasString(value, "normalized_at")) return false;
+  if (!isCanonicalRawSourceRef(value.raw_source_ref)) return false;
+
+  switch (value.record_kind) {
+    case "session":
+      return (
+        hasSessionScope(value) &&
+        (value.completion_status === undefined ||
+          includesValue(CANONICAL_COMPLETION_STATUSES, value.completion_status))
+      );
+    case "prompt":
+      return (
+        hasSessionScope(value) &&
+        hasString(value, "prompt_id") &&
+        hasString(value, "occurred_at") &&
+        hasString(value, "prompt_text") &&
+        includesValue(CANONICAL_PROMPT_KINDS, value.prompt_kind) &&
+        typeof value.is_actionable === "boolean"
+      );
+    case "skill_invocation":
+      return (
+        hasSessionScope(value) &&
+        hasString(value, "skill_invocation_id") &&
+        hasString(value, "occurred_at") &&
+        (value.matched_prompt_id === undefined || hasString(value, "matched_prompt_id")) &&
+        hasString(value, "skill_name") &&
+        includesValue(CANONICAL_INVOCATION_MODES, value.invocation_mode) &&
+        typeof value.triggered === "boolean" &&
+        isFiniteNumber(value.confidence)
+      );
+    case "execution_fact":
+      return (
+        hasSessionScope(value) &&
+        hasString(value, "execution_fact_id") &&
+        hasString(value, "occurred_at") &&
+        isNumberRecord(value.tool_calls_json) &&
+        isFiniteNumber(value.total_tool_calls) &&
+        (value.bash_commands_redacted === undefined ||
+          isStringArray(value.bash_commands_redacted)) &&
+        isFiniteNumber(value.assistant_turns) &&
+        isFiniteNumber(value.errors_encountered) &&
+        (value.completion_status === undefined ||
+          includesValue(CANONICAL_COMPLETION_STATUSES, value.completion_status))
+      );
+    case "normalization_run":
+      return (
+        hasString(value, "run_id") &&
+        hasString(value, "run_at") &&
+        isFiniteNumber(value.raw_records_seen) &&
+        isFiniteNumber(value.canonical_records_written) &&
+        typeof value.repair_applied === "boolean"
+      );
+    default:
+      return false;
+  }
+}

package/node_modules/@selftune/telemetry-contract/tests/compatibility.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from "bun:test";
+
+import { completePush } from "../fixtures/complete-push.js";
+import { evidenceOnlyPush } from "../fixtures/evidence-only-push.js";
+import { partialPushNoSessions } from "../fixtures/partial-push-no-sessions.js";
+import { partialPushUnresolvedParents } from "../fixtures/partial-push-unresolved-parents.js";
+import { PushPayloadV2Schema } from "../src/schemas.js";
+
+describe("PushPayloadV2Schema compatibility", () => {
+  // ---- Fixture validation ----
+
+  test("complete-push fixture passes validation", () => {
+    const result = PushPayloadV2Schema.safeParse(completePush);
+    if (!result.success) {
+      throw new Error(`Validation failed: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  test("partial-push-no-sessions fixture passes validation", () => {
+    const result = PushPayloadV2Schema.safeParse(partialPushNoSessions);
+    if (!result.success) {
+      throw new Error(`Validation failed: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  test("partial-push-unresolved-parents fixture passes validation", () => {
+    const result = PushPayloadV2Schema.safeParse(partialPushUnresolvedParents);
+    if (!result.success) {
+      throw new Error(`Validation failed: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  test("evidence-only-push fixture passes validation", () => {
+    const result = PushPayloadV2Schema.safeParse(evidenceOnlyPush);
+    if (!result.success) {
+      throw new Error(`Validation failed: ${JSON.stringify(result.error.issues, null, 2)}`);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  // ---- execution_fact_id is required ----
+
+  test("execution_fact_id is required on execution facts", () => {
+    const badPayload = structuredClone(completePush);
+    delete (badPayload.canonical.execution_facts[0] as Record<string, unknown>).execution_fact_id;
+    const result = PushPayloadV2Schema.safeParse(badPayload);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const paths = result.error.issues.map((i) => i.path.join("."));
+      expect(paths).toContain("canonical.execution_facts.0.execution_fact_id");
+    }
+  });
+
+  test("execution_fact_id rejects empty string", () => {
+    const badPayload = structuredClone(completePush);
+    (badPayload.canonical.execution_facts[0] as Record<string, unknown>).execution_fact_id = "";
+    const result = PushPayloadV2Schema.safeParse(badPayload);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      const paths = result.error.issues.map((i) => i.path.join("."));
+      expect(paths).toContain("canonical.execution_facts.0.execution_fact_id");
+    }
+  });
+
+  // ---- bash_commands_redacted is optional ----
+
+  test("bash_commands_redacted is optional (omitting it passes)", () => {
+    // The unresolved-parents fixture already omits bash_commands_redacted
+    const ef = partialPushUnresolvedParents.canonical.execution_facts[0];
+    expect(ef.bash_commands_redacted).toBeUndefined();
+
+    const result = PushPayloadV2Schema.safeParse(partialPushUnresolvedParents);
+    expect(result.success).toBe(true);
+  });
+
+  test("bash_commands_redacted accepts an array when present", () => {
+    const ef = completePush.canonical.execution_facts[0];
+    expect(Array.isArray(ef.bash_commands_redacted)).toBe(true);
+
+    const result = PushPayloadV2Schema.safeParse(completePush);
+    expect(result.success).toBe(true);
+  });
+
+  // ---- Zero-session pushes ----
+
+  test("zero-session pushes pass validation", () => {
+    expect(partialPushNoSessions.canonical.sessions).toHaveLength(0);
+    const result = PushPayloadV2Schema.safeParse(partialPushNoSessions);
+    expect(result.success).toBe(true);
+  });
+
+  test("evidence-only push with all empty arrays passes", () => {
+    expect(evidenceOnlyPush.canonical.sessions).toHaveLength(0);
+    expect(evidenceOnlyPush.canonical.prompts).toHaveLength(0);
+    expect(evidenceOnlyPush.canonical.skill_invocations).toHaveLength(0);
+    expect(evidenceOnlyPush.canonical.execution_facts).toHaveLength(0);
+    expect(evidenceOnlyPush.canonical.normalization_runs).toHaveLength(0);
+    const result = PushPayloadV2Schema.safeParse(evidenceOnlyPush);
+    expect(result.success).toBe(true);
+  });
+
+  // ---- Unresolved parent references ----
+
+  test("unresolved parent references pass (invocation references session_id not in sessions)", () => {
+    const sessionIds = new Set(
+      partialPushUnresolvedParents.canonical.sessions.map((s) => s.session_id),
+    );
+    const invSessionIds = partialPushUnresolvedParents.canonical.skill_invocations.map(
+      (i) => i.session_id,
+    );
+
+    // Precondition: arrays must be non-empty for the test to be meaningful
+    expect(invSessionIds.length).toBeGreaterThan(0);
+
+    // Confirm the invocation references a session not in the sessions array
+    for (const sid of invSessionIds) {
+      expect(sessionIds.has(sid)).toBe(false);
+    }
+
+    const result = PushPayloadV2Schema.safeParse(partialPushUnresolvedParents);
+    expect(result.success).toBe(true);
+  });
+
+  test("prompts with unresolved session_id pass validation", () => {
+    const sessionIds = new Set(
+      partialPushUnresolvedParents.canonical.sessions.map((s) => s.session_id),
+    );
+    const promptSessionIds = partialPushUnresolvedParents.canonical.prompts.map(
+      (p) => p.session_id,
+    );
+
+    // Precondition: arrays must be non-empty for the test to be meaningful
+    expect(promptSessionIds.length).toBeGreaterThan(0);
+
+    for (const sid of promptSessionIds) {
+      expect(sessionIds.has(sid)).toBe(false);
+    }
+
+    const result = PushPayloadV2Schema.safeParse(partialPushUnresolvedParents);
+    expect(result.success).toBe(true);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "selftune",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "Self-improving skills CLI for AI agents",
   "keywords": [
     "agent",
@@ -82,5 +82,8 @@
     "@types/bun": "^1.1.0",
     "oxfmt": "^0.41.0",
     "oxlint": "^1.56.0"
-  }
+  },
+  "bundledDependencies": [
+    "@selftune/telemetry-contract"
+  ]
 }

package/packages/telemetry-contract/node_modules/zod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.