selftune 0.2.0 → 0.2.2

package/cli/selftune/workflows/skill-md-writer.ts

@@ -0,0 +1,288 @@
+/**
+ * skill-md-writer.ts
+ *
+ * Line-based parser and writer for the `## Workflows` section in SKILL.md files.
+ * Pure functions, zero dependencies — follows the frontmatter.ts pattern.
+ */
+
+import type { CodifiedWorkflow } from "../types.js";
+
+type WorkflowBuilder = Pick<CodifiedWorkflow, "name" | "skills" | "source"> &
+  Partial<Pick<CodifiedWorkflow, "description" | "discovered_from">>;
+
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse existing `## Workflows` section from SKILL.md content.
+ * Returns an empty array if the section is missing or empty.
+ */
+export function parseWorkflowsSection(content: string): CodifiedWorkflow[] {
+  const lines = content.split("\n");
+  const workflows: CodifiedWorkflow[] = [];
+
+  // Find the ## Workflows heading
+  let sectionStart = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === "## Workflows") {
+      sectionStart = i + 1;
+      break;
+    }
+  }
+
+  if (sectionStart < 0) return [];
+
+  // Find the end of the section (next ## heading or EOF)
+  let sectionEnd = lines.length;
+  for (let i = sectionStart; i < lines.length; i++) {
+    if (/^## /.test(lines[i]) && lines[i].trim() !== "## Workflows") {
+      sectionEnd = i;
+      break;
+    }
+  }
+
+  // Parse each ### subsection within the workflows section
+  const sectionLines = lines.slice(sectionStart, sectionEnd);
+  let current: WorkflowBuilder | null = null;
+
+  for (const line of sectionLines) {
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith("### ")) {
+      // Save previous workflow if any
+      if (current) workflows.push(current);
+      current = {
+        name: trimmed.slice(4).trim(),
+        skills: [],
+        source: "authored",
+      };
+      continue;
+    }
+
+    if (!current) continue;
+
+    if (trimmed.startsWith("- **Skills:**")) {
+      const skillsStr = trimmed.slice("- **Skills:**".length).trim();
+      current.skills = skillsStr
+        .split(" \u2192 ")
+        .map((s) => s.trim())
+        .filter(Boolean);
+      continue;
+    }
+
+    if (trimmed.startsWith("- **Trigger:**")) {
+      current.description = trimmed.slice("- **Trigger:**".length).trim();
+      continue;
+    }
+
+    if (trimmed.startsWith("- **Source:**")) {
+      const sourceStr = trimmed.slice("- **Source:**".length).trim();
+      const discoveredMatch = sourceStr.match(
+        /^Discovered from (\d+) sessions? \(synergy: (-?\d+(?:\.\d+)?)\)$/,
+      );
+      if (discoveredMatch) {
+        current.source = "discovered";
+        current.discovered_from = {
+          workflow_id: current.skills.join("\u2192"),
+          occurrence_count: parseInt(discoveredMatch[1], 10),
+          synergy_score: parseFloat(discoveredMatch[2]),
+        };
+      } else {
+        current.source = "authored";
+      }
+    }
+  }
+
+  // Don't forget the last workflow
+  if (current) workflows.push(current);
+
+  return workflows;
+}
+
+// ---------------------------------------------------------------------------
+// Writer — append
+// ---------------------------------------------------------------------------
+
+/**
+ * Format a single workflow as a markdown subsection.
+ */
+function formatWorkflowSubsection(workflow: CodifiedWorkflow): string {
+  const lines: string[] = [];
+  lines.push(`### ${workflow.name}`);
+  lines.push(`- **Skills:** ${workflow.skills.join(" \u2192 ")}`);
+  if (workflow.description) {
+    lines.push(`- **Trigger:** ${workflow.description}`);
+  }
+
+  if (workflow.source === "discovered" && workflow.discovered_from) {
+    const { occurrence_count, synergy_score } = workflow.discovered_from;
+    lines.push(
+      `- **Source:** Discovered from ${occurrence_count} sessions (synergy: ${synergy_score.toFixed(2)})`,
+    );
+  } else {
+    lines.push(`- **Source:** authored`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Append a workflow to the `## Workflows` section.
+ * Creates the section if it doesn't exist.
+ * Returns content unchanged if a workflow with the same name already exists.
+ */
+export function appendWorkflow(content: string, workflow: CodifiedWorkflow): string {
+  // Check for duplicate
+  const existing = parseWorkflowsSection(content);
+  if (existing.some((w) => w.name === workflow.name)) {
+    return content;
+  }
+
+  const subsection = formatWorkflowSubsection(workflow);
+  const lines = content.split("\n");
+
+  // Find the ## Workflows heading
+  let sectionStart = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === "## Workflows") {
+      sectionStart = i;
+      break;
+    }
+  }
+
+  if (sectionStart >= 0) {
+    // Find the end of the workflows section (next ## heading or EOF)
+    let sectionEnd = lines.length;
+    for (let i = sectionStart + 1; i < lines.length; i++) {
+      if (/^## /.test(lines[i])) {
+        sectionEnd = i;
+        break;
+      }
+    }
+
+    // Insert before the next ## heading (or at EOF)
+    const before = lines.slice(0, sectionEnd);
+    const after = lines.slice(sectionEnd);
+
+    // Ensure blank line before the new subsection
+    const lastNonEmpty = findLastNonEmptyIndex(before);
+    const needsBlankLine = lastNonEmpty >= 0 && lastNonEmpty === before.length - 1;
+
+    const result: string[] = [...before];
+    if (needsBlankLine) result.push("");
+    result.push(subsection);
+    if (after.length > 0) {
+      result.push("");
+      result.push(...after);
+    }
+    return result.join("\n");
+  }
+
+  // No ## Workflows section — append at end
+  const trimmedContent = content.replace(/\n*$/, "");
+  return `${trimmedContent}\n\n## Workflows\n\n${subsection}\n`;
+}
+
+// ---------------------------------------------------------------------------
+// Writer — remove
+// ---------------------------------------------------------------------------
+
+/**
+ * Remove a workflow by name from the `## Workflows` section.
+ * If the section becomes empty after removal, the section heading is also removed.
+ * Returns content unchanged if the workflow is not found.
+ */
+export function removeWorkflow(content: string, name: string): string {
+  const lines = content.split("\n");
+
+  // Find the ## Workflows heading
+  let sectionStart = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === "## Workflows") {
+      sectionStart = i;
+      break;
+    }
+  }
+
+  if (sectionStart < 0) return content;
+
+  // Find the end of the workflows section
+  let sectionEnd = lines.length;
+  for (let i = sectionStart + 1; i < lines.length; i++) {
+    if (/^## /.test(lines[i])) {
+      sectionEnd = i;
+      break;
+    }
+  }
+
+  // Find the ### <name> subsection
+  let subStart = -1;
+  let subEnd = -1;
+
+  for (let i = sectionStart + 1; i < sectionEnd; i++) {
+    if (lines[i].trim() === `### ${name}`) {
+      subStart = i;
+      // Find the end of this subsection (next ### or ## or sectionEnd)
+      subEnd = sectionEnd;
+      for (let j = i + 1; j < sectionEnd; j++) {
+        if (/^### /.test(lines[j])) {
+          subEnd = j;
+          break;
+        }
+      }
+      break;
+    }
+  }
+
+  if (subStart < 0) return content;
+
+  // Remove blank lines before the subsection (cleanup)
+  let removeFrom = subStart;
+  while (removeFrom > sectionStart + 1 && lines[removeFrom - 1].trim() === "") {
+    removeFrom--;
+  }
+
+  // Remove blank lines after the subsection (cleanup)
+  let removeTo = subEnd;
+  while (removeTo < sectionEnd && lines[removeTo]?.trim() === "") {
+    removeTo++;
+  }
+
+  // Build result without the removed subsection
+  const before = lines.slice(0, removeFrom);
+  const after = lines.slice(removeTo);
+
+  // Check if the workflows section is now empty
+  const remaining = [...before.slice(sectionStart + 1), ...after.slice(0, sectionEnd - removeTo)];
+  const hasRemainingWorkflows = remaining.some((l) => /^### /.test(l));
+
+  if (!hasRemainingWorkflows) {
+    // Remove the entire ## Workflows section (heading + any blank lines)
+    let headingStart = sectionStart;
+    // Remove blank lines before the heading too
+    while (headingStart > 0 && lines[headingStart - 1].trim() === "") {
+      headingStart--;
+    }
+
+    const beforeSection = lines.slice(0, headingStart);
+    const afterSection = lines.slice(removeTo);
+
+    const result = [...beforeSection, ...afterSection].join("\n");
+    // Clean up trailing newlines
+    return result.replace(/\n{3,}$/, "\n");
+  }
+
+  return [...before, ...after].join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findLastNonEmptyIndex(lines: string[]): number {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].trim() !== "") return i;
+  }
+  return -1;
+}

package/cli/selftune/workflows/workflows.ts

@@ -0,0 +1,188 @@
+/**
+ * workflows.ts
+ *
+ * CLI entry point and formatter for multi-skill workflow discovery and management.
+ *
+ * Exports:
+ *  - formatWorkflows()  (pure formatter, deterministic)
+ *  - cliMain()          (reads logs, discovers workflows, prints output or saves)
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { TELEMETRY_LOG } from "../constants.js";
+import type {
+  CodifiedWorkflow,
+  SessionTelemetryRecord,
+  WorkflowDiscoveryReport,
+} from "../types.js";
+import { readJsonl } from "../utils/jsonl.js";
+import { readEffectiveSkillUsageRecords } from "../utils/skill-log.js";
+import { discoverWorkflows } from "./discover.js";
+import { appendWorkflow } from "./skill-md-writer.js";
+
+// ---------------------------------------------------------------------------
+// formatWorkflows — pure formatter
+// ---------------------------------------------------------------------------
+
+export function formatWorkflows(report: WorkflowDiscoveryReport): string {
+  if (report.workflows.length === 0) {
+    return "No workflows discovered.";
+  }
+
+  const lines: string[] = [];
+  lines.push(`Discovered Workflows (from ${report.total_sessions_analyzed} sessions):`);
+  lines.push("");
+
+  for (let i = 0; i < report.workflows.length; i++) {
+    const wf = report.workflows[i];
+    const chain = wf.skills.join(" \u2192 ");
+    const synergy = wf.synergy_score.toFixed(2);
+    const consistency = Math.round(wf.sequence_consistency * 100);
+    const completion = Math.round(wf.completion_rate * 100);
+
+    lines.push(`  ${i + 1}. ${chain}`);
+    lines.push(
+      `     Occurrences: ${wf.occurrence_count} | Synergy: ${synergy} | Consistency: ${consistency}% | Completion: ${completion}%`,
+    );
+    if (wf.representative_query) {
+      lines.push(`     Common trigger: "${wf.representative_query}"`);
+    }
+    if (i < report.workflows.length - 1) {
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// cliMain — reads logs, discovers workflows, prints or saves
+// ---------------------------------------------------------------------------
+
+export async function cliMain(): Promise<void> {
+  const { values, positionals } = parseArgs({
+    options: {
+      "min-occurrences": { type: "string" },
+      window: { type: "string" },
+      skill: { type: "string" },
+      "skill-path": { type: "string" },
+      json: { type: "boolean" },
+    },
+    strict: true,
+    allowPositionals: true,
+  });
+
+  const subcommand = positionals[0];
+  const minOccurrences = values["min-occurrences"]
+    ? Number.parseInt(values["min-occurrences"], 10)
+    : undefined;
+  if (minOccurrences !== undefined && (Number.isNaN(minOccurrences) || minOccurrences < 0)) {
+    console.error("[ERROR] --min-occurrences must be a non-negative integer.");
+    process.exit(1);
+  }
+  const window = values.window ? Number.parseInt(values.window, 10) : undefined;
+  if (window !== undefined && (Number.isNaN(window) || window < 0)) {
+    console.error("[ERROR] --window must be a non-negative integer.");
+    process.exit(1);
+  }
+
+  // Read telemetry and skill usage logs
+  const telemetry = readJsonl<SessionTelemetryRecord>(TELEMETRY_LOG);
+  const usage = readEffectiveSkillUsageRecords();
+
+  // Discover workflows
+  const report = discoverWorkflows(telemetry, usage, {
+    minOccurrences,
+    window,
+    skill: values.skill,
+  });
+
+  if (subcommand === "save") {
+    // Save subcommand: find workflow, append to SKILL.md
+    const nameArg = positionals[1];
+    if (!nameArg) {
+      console.error("[ERROR] Usage: selftune workflows save <name-or-index>");
+      process.exit(1);
+    }
+
+    // Match by numeric index (1-based) or workflow_id
+    let workflow = report.workflows.find((w) => w.workflow_id === nameArg);
+    if (!workflow) {
+      const idx = Number.parseInt(nameArg, 10);
+      if (!Number.isNaN(idx) && idx >= 1 && idx <= report.workflows.length) {
+        workflow = report.workflows[idx - 1];
+      }
+    }
+
+    if (!workflow) {
+      console.error(`[ERROR] No workflow found matching "${nameArg}".`);
+      console.error("Run 'selftune workflows' to see discovered workflows and their indices.");
+      process.exit(1);
+    }
+
+    // Determine SKILL.md path
+    let skillPath = values["skill-path"];
+    if (!skillPath) {
+      // Filter usage records to only sessions that contributed to this workflow
+      const sessionSet = new Set(workflow.session_ids);
+      const firstSkill = workflow.skills[0];
+      const matchingRecords = usage.filter(
+        (u) => u.skill_name === firstSkill && sessionSet.has(u.session_id),
+      );
+
+      // Collect unique skill_paths from matching records
+      const uniquePaths = [...new Set(matchingRecords.map((r) => r.skill_path))];
+
+      if (uniquePaths.length === 1) {
+        skillPath = uniquePaths[0];
+      } else if (uniquePaths.length > 1) {
+        // Ambiguous: multiple SKILL.md paths found across contributing sessions
+        console.error(`[ERROR] Multiple SKILL.md paths found for "${firstSkill}":`);
+        for (const p of uniquePaths) {
+          console.error(`  - ${p}`);
+        }
+        console.error("Use --skill-path to specify which one to update.");
+        process.exit(1);
+      }
+    }
+
+    if (!skillPath || !existsSync(skillPath)) {
+      console.error(`[ERROR] Could not determine SKILL.md path. Use --skill-path to specify.`);
+      process.exit(1);
+    }
+
+    // Build CodifiedWorkflow
+    const codified: CodifiedWorkflow = {
+      name: workflow.skills.join("-"),
+      skills: workflow.skills,
+      description: workflow.representative_query || undefined,
+      source: "discovered",
+      discovered_from: {
+        workflow_id: workflow.workflow_id,
+        occurrence_count: workflow.occurrence_count,
+        synergy_score: workflow.synergy_score,
+      },
+    };
+
+    // Read, append, write
+    const content = readFileSync(skillPath, "utf-8");
+    const updated = appendWorkflow(content, codified);
+
+    if (updated === content) {
+      console.log(`Workflow "${codified.name}" already exists in ${skillPath}`);
+    } else {
+      writeFileSync(skillPath, updated, "utf-8");
+      console.log(`Saved workflow "${codified.name}" to ${skillPath}`);
+    }
+
+    return;
+  }
+
+  // Default: discover and display
+  if (values.json || !process.stdout.isTTY) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(formatWorkflows(report));
+  }
+}

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "selftune",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Self-improving skills CLI for AI agents",
   "type": "module",
   "license": "MIT",
   "author": "Daniel Petro",
-  "homepage": "https://github.com/WellDunDun/selftune#readme",
+  "homepage": "https://github.com/selftune-dev/selftune#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/WellDunDun/selftune.git"
+    "url": "git+https://github.com/selftune-dev/selftune.git"
   },
   "bugs": {
-    "url": "https://github.com/WellDunDun/selftune/issues"
+    "url": "https://github.com/selftune-dev/selftune/issues"
   },
   "funding": {
     "type": "github",
@@ -40,7 +40,8 @@
     "assets/",
     "bin/",
     "cli/selftune/",
-    "dashboard/",
+    "apps/local-dashboard/dist/",
+    "packages/telemetry-contract/",
     "templates/",
     ".claude/agents/",
     "skill/",
@@ -48,15 +49,27 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "lint": "bunx biome check .",
-    "lint:fix": "bunx biome check --write .",
+    "dev": "sh -c 'if lsof -iTCP:7888 -sTCP:LISTEN >/dev/null 2>&1; then if curl -fsS http://127.0.0.1:7888/api/health | grep -q selftune-dashboard; then echo \"Using existing dashboard server on 7888\"; cd apps/local-dashboard && bun install && bunx vite --strictPort; else echo \"Port 7888 is occupied by a non-selftune service\"; exit 1; fi; else cd apps/local-dashboard && bun install && bun run dev; fi'",
+    "dev:dashboard": "bun run cli/selftune/index.ts dashboard --port 7888 --no-open",
+    "lint": "bunx @biomejs/biome check .",
+    "lint:fix": "bunx @biomejs/biome check --write .",
     "lint:arch": "bun run lint-architecture.ts",
     "test": "bun test",
+    "test:fast": "bun test $(find tests -name '*.test.ts' ! -name 'evolve.test.ts' ! -name 'integration.test.ts' ! -name 'dashboard-server.test.ts' ! -path '*/blog-proof/*')",
+    "test:slow": "bun test tests/evolution/evolve.test.ts tests/evolution/integration.test.ts tests/monitoring/integration.test.ts tests/dashboard/dashboard-server.test.ts",
+    "build:dashboard": "cd apps/local-dashboard && bun install && bunx vite build",
+    "prepublishOnly": "bun run build:dashboard",
     "check": "bun run lint && bun run lint:arch && bun test",
     "start": "bun run cli/selftune/index.ts --help"
   },
+  "workspaces": [
+    "packages/*"
+  ],
+  "dependencies": {
+    "@selftune/telemetry-contract": "workspace:*"
+  },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.4",
+    "@biomejs/biome": "2.4.7",
     "@types/bun": "^1.1.0"
   }
 }

package/packages/telemetry-contract/README.md

@@ -0,0 +1,11 @@
+# @selftune/telemetry-contract
+
+Canonical telemetry contract shared between local CLI normalization and cloud ingestion.
+
+This package is intentionally small:
+
+- canonical enums
+- canonical record types
+- lightweight runtime guards
+
+It does not include adapter logic, projections, or product-specific analytics.

package/packages/telemetry-contract/fixtures/golden.json

@@ -0,0 +1,87 @@
+[
+  {
+    "_description": "Minimal valid session record",
+    "record_kind": "session",
+    "schema_version": "2.0",
+    "normalizer_version": "0.2.1",
+    "normalized_at": "2026-01-15T12:00:00Z",
+    "platform": "claude_code",
+    "capture_mode": "hook",
+    "raw_source_ref": { "path": "/tmp/raw/session-001.jsonl" },
+    "source_session_kind": "interactive",
+    "session_id": "golden-session-001",
+    "started_at": "2026-01-15T11:50:00Z",
+    "ended_at": "2026-01-15T12:05:00Z",
+    "completion_status": "completed"
+  },
+  {
+    "_description": "Minimal valid prompt record",
+    "record_kind": "prompt",
+    "schema_version": "2.0",
+    "normalizer_version": "0.2.1",
+    "normalized_at": "2026-01-15T12:00:00Z",
+    "platform": "claude_code",
+    "capture_mode": "hook",
+    "raw_source_ref": { "path": "/tmp/raw/session-001.jsonl", "line": 3 },
+    "source_session_kind": "interactive",
+    "session_id": "golden-session-001",
+    "prompt_id": "golden-prompt-001",
+    "occurred_at": "2026-01-15T11:51:00Z",
+    "prompt_text": "Fix the login bug",
+    "prompt_kind": "user",
+    "is_actionable": true
+  },
+  {
+    "_description": "Minimal valid skill_invocation record",
+    "record_kind": "skill_invocation",
+    "schema_version": "2.0",
+    "normalizer_version": "0.2.1",
+    "normalized_at": "2026-01-15T12:00:00Z",
+    "platform": "claude_code",
+    "capture_mode": "hook",
+    "raw_source_ref": { "path": "/tmp/raw/session-001.jsonl", "line": 7 },
+    "source_session_kind": "interactive",
+    "session_id": "golden-session-001",
+    "skill_invocation_id": "golden-invocation-001",
+    "occurred_at": "2026-01-15T11:52:00Z",
+    "matched_prompt_id": "golden-prompt-001",
+    "skill_name": "commit",
+    "invocation_mode": "explicit",
+    "triggered": true,
+    "confidence": 1.0
+  },
+  {
+    "_description": "Minimal valid execution_fact record",
+    "record_kind": "execution_fact",
+    "schema_version": "2.0",
+    "normalizer_version": "0.2.1",
+    "normalized_at": "2026-01-15T12:00:00Z",
+    "platform": "claude_code",
+    "capture_mode": "hook",
+    "raw_source_ref": { "path": "/tmp/raw/session-001.jsonl", "line": 15 },
+    "source_session_kind": "interactive",
+    "session_id": "golden-session-001",
+    "occurred_at": "2026-01-15T12:04:00Z",
+    "tool_calls_json": { "Read": 5, "Edit": 3, "Bash": 2 },
+    "total_tool_calls": 10,
+    "bash_commands_redacted": ["git status", "bun test"],
+    "assistant_turns": 4,
+    "errors_encountered": 0,
+    "completion_status": "completed"
+  },
+  {
+    "_description": "Minimal valid normalization_run record",
+    "record_kind": "normalization_run",
+    "schema_version": "2.0",
+    "normalizer_version": "0.2.1",
+    "normalized_at": "2026-01-15T12:00:00Z",
+    "platform": "claude_code",
+    "capture_mode": "hook",
+    "raw_source_ref": {},
+    "run_id": "golden-run-001",
+    "run_at": "2026-01-15T12:00:00Z",
+    "raw_records_seen": 42,
+    "canonical_records_written": 38,
+    "repair_applied": false
+  }
+]

package/packages/telemetry-contract/fixtures/golden.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CANONICAL_SCHEMA_VERSION } from "../src/types.js";
+import { isCanonicalRecord } from "../src/validators.js";
+
+const fixtures = JSON.parse(
+  readFileSync(join(import.meta.dirname, "golden.json"), "utf-8"),
+) as Record<string, unknown>[];
+
+describe("golden fixtures", () => {
+  test("all fixtures pass isCanonicalRecord", () => {
+    for (const fixture of fixtures) {
+      const desc = fixture._description ?? fixture.record_kind;
+      const result = isCanonicalRecord(fixture);
+      if (!result) throw new Error(`Failed: ${desc}`);
+      expect(result).toBe(true);
+    }
+  });
+
+  test("all fixtures use current schema version", () => {
+    for (const fixture of fixtures) {
+      expect(fixture.schema_version).toBe(CANONICAL_SCHEMA_VERSION);
+    }
+  });
+
+  test("covers every record_kind", () => {
+    const kinds = new Set(fixtures.map((f) => f.record_kind));
+    expect(kinds).toContain("session");
+    expect(kinds).toContain("prompt");
+    expect(kinds).toContain("skill_invocation");
+    expect(kinds).toContain("execution_fact");
+    expect(kinds).toContain("normalization_run");
+  });
+
+  test("mutated fixtures fail validation", () => {
+    for (const fixture of fixtures) {
+      const bad = { ...fixture, schema_version: "0.0" };
+      expect(isCanonicalRecord(bad)).toBe(false);
+    }
+  });
+});

package/packages/telemetry-contract/index.ts

@@ -0,0 +1 @@
+export * from "./src/index.js";