@zhixuan92/multi-model-agent-core 3.9.0 → 3.10.0

package/dist/telemetry/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/telemetry/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,aAIE,CAAC;AAcjC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;4BAAqD,CAAC;AAEpF,eAAO,MAAM,QAAQ,aAAoB,CAAC;AAE1C,eAAO,MAAM,WAAW;;;;;;;;;;;;;EAab,CAAC;AACZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE1D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;EAqBnB,CAAC;AAGH,eAAO,MAAM,cAAc;;;;;;EAMzB,CAAC;AAEH,eAAO,MAAM,EAAE;;;;;EAAgD,CAAC;AAEhE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOjB,CAAC;AASZ,eAAO,MAAM,mBAAmB;;;;;;;;;EAS9B,CAAC;AAGH,eAAO,MAAM,SAAS;;;;;;;;;;;;EAYpB,CAAC;AAIH,eAAO,MAAM,eAAe;;;;;;;;;;EAU1B,CAAC;AAIH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOZ,CAAC;AAGZ,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAS3B,CAAC;AAGH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG3B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoEpB,CAAC;AAEZ,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;kBAWrB,CAAC;AAEZ,eAAO,MAAM,mBAAmB;;;;;;;;;kBAKrB,CAAC;AAEZ,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;kBAIrB,CAAC;AAMZ,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA8IvB,CAAC;AAGL,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIb,CAAC;AAGZ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAChE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAC1D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAClE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACxE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC1E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC1E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAClE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AACpD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACxE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/telemetry/types.ts"],"names":[],"mappings":"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"}

package/dist/telemetry/types.js

@@ -1,111 +1,32 @@
 import { z } from 'zod';
-export const SCHEMA_VERSION = 2;
-/**
- * Permissive shape-only validation for fields whose vocabulary we don't control:
- * model IDs, client names, MCP tool names, skill IDs. Charset accommodates every
- * model namespace observed in the wild (Anthropic, OpenAI, Bedrock prefixes,
- * OpenRouter `meta-llama/...`, Ollama `model:tag`). Length cap prevents PII
- * smuggling. The schema validates SHAPE, not VOCABULARY.
- */
-export const BoundedIdentifier = z
-    .string()
-    .min(1)
-    .max(120)
-    .regex(/^[A-Za-z0-9._:/\-]+$/);
-const MAX_STR = 64;
-const MAX_VERSION_STR = 64;
+import { ModelFamilyEnum } from '../routing/model-profiles.js';
+export const SCHEMA_VERSION = 3;
+export const STRICT_ID_REGEX = /^[A-Za-z0-9][-A-Za-z0-9_.:+/@]{0,119}$/;
+// ── Batch wrapper (§3.1) ─────────────────────────────────────────────────
 const VersionString = z
     .string()
     .regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/)
-    .max(MAX_VERSION_STR);
-// Allowlists. Two skill enums: triggering source vs installable skill.
-// 'direct' is only meaningful for triggering (no skill caller); it cannot be installed.
-export const InstallableSkillId = z.enum([
-    'mma-delegate',
-    'mma-audit',
-    'mma-review',
-    'mma-verify',
-    'mma-debug',
-    'mma-execute-plan',
-    'mma-retry',
-    'mma-investigate', // present on disk under packages/server/src/skills/
-    'mma-context-blocks',
-    'mma-clarifications',
-    'other', // sentinel for unknown / community skill
-]);
-export const TriggeringSkillId = z.union([InstallableSkillId, z.literal('direct')]);
-export const ClientId = BoundedIdentifier;
-export const ModelFamily = z.enum([
-    'claude', // Anthropic
-    'openai', // OpenAI
-    'gemini', // Google
-    'deepseek', // DeepSeek
-    'grok', // xAI
-    'mistral', // Mistral
-    'meta', // Meta (Llama family — covers llama2:7b, meta-llama/..., etc.)
-    'qwen', // Alibaba
-    'zhipu', // Z.ai (GLM family)
-    'kimi', // Moonshot
-    'minimax', // MiniMax
-    'other', // catch-all — never rejected
-]);
-export const Language = z.enum([
-    'en',
-    'es',
-    'fr',
-    'de',
-    'zh',
-    'ja',
-    'ko',
-    'pt',
-    'ru',
-    'it',
-    'tr',
-    'ar',
-    'hi',
-    'vi',
-    'id',
-    'th',
-    'pl',
-    'nl',
-    'sv',
-    'other',
-]);
-// Time-zone offset buckets, fully covering UTC-12 through UTC+14, half-open [a, b).
-export const TzOffsetBucket = z.enum([
-    'utc_minus_12_to_minus_6', // [-12, -6)
-    'utc_minus_6_to_0', // [-6, 0)
-    'utc_0_to_plus_6', // [0, +6)
-    'utc_plus_6_to_plus_12', // [+6, +12)
-    'utc_plus_12_to_plus_15', // [+12, +15)  -- covers UTC+12, +12:45, +13, +14
-]);
-export const Os = z.enum(['darwin', 'linux', 'win32', 'other']); // matches process.platform; non-listed → 'other'
-export const InstallMetadata = z.object({
+    .max(64);
+export const Os = z.enum(['darwin', 'linux', 'win32', 'other']);
+export const BatchWrapperSchema = z.object({
+    schemaVersion: z.literal(3),
     installId: z.string().uuid(),
     mmagentVersion: VersionString,
     os: Os,
-    nodeMajor: z.string().regex(/^[1-9]\d?$/).max(2), // "1".."99"; no leading zeros; cast to int when sorting
-    language: Language, // bucketed from runtime locale, never raw
-    tzOffsetBucket: TzOffsetBucket,
+    nodeMajor: z.number().int().min(22).max(99),
 }).strict();
-// Allowlist of tool names that may appear in topToolNames. Anything else → 'other'.
-// This is the SDK-level tool surface from packages/core/src/tools/definitions.ts;
-// the canonical names used here are the camelCase internal names. The adapter-facing
-// snake_case names (read_file, write_file, edit_file, run_shell, list_files) are
-// normalized to camelCase by the event-builder before counting. Web search and web
-// fetch are NOT separate tool names — they are surfaced via the `capabilities` field
-// on TaskCompletedEvent and excluded from topToolNames.
-export const AllowlistedToolName = z.enum([
-    'readFile',
-    'writeFile',
-    'editFile',
-    'runShell',
-    'listFiles',
-    'grep',
-    'glob',
+// ── Enums shared across stages and top-level ─────────────────────────────
+export const ConcernCategory = z.enum([
+    'missing_test',
+    'scope_creep',
+    'incomplete_impl',
+    'style_lint',
+    'security',
+    'performance',
+    'maintainability',
+    'doc_gap',
     'other',
 ]);
-// Allowlist of error codes from packages/core/src/types.ts:RunResult.structuredError
 export const ErrorCode = z.enum([
     'verify_command_error',
     'commit_metadata_invalid',
@@ -119,280 +40,218 @@ export const ErrorCode = z.enum([
     'rate_limit_exceeded',
     'other',
 ]);
-// Allowlist of structured concern categories surfaced by reviewers.
-// Server categorizes raw concern messages into these buckets at ingest time.
-export const ConcernCategory = z.enum([
-    'missing_test',
-    'scope_creep',
-    'incomplete_impl',
-    'style_lint',
-    'security',
-    'performance',
-    'maintainability',
-    'doc_gap',
-    'other',
-]);
-// Per-stage breakdown — populated for stages the task actually entered.
-// Each sub-object is null when the stage was not entered.
-export const StageStats = z.object({
-    entered: z.boolean(),
-    durationBucket: z.enum(['<10s', '10s-1m', '1m-5m', '5m-30m', '30m+']).nullable(),
-    costBucket: z.enum(['$0', '<$0.01', '$0.01-$0.10', '$0.10-$1', '$1+']).nullable(),
-    agentTier: z.enum(['standard', 'complex']).nullable(),
-    modelFamily: ModelFamily.nullable(),
-    model: BoundedIdentifier.nullable(),
+export const SeverityBin = z.enum(['high', 'medium', 'low', 'style']);
+export const FindingsBySeveritySchema = z.object({
+    high: z.number().int().min(0).max(50),
+    medium: z.number().int().min(0).max(50),
+    low: z.number().int().min(0).max(50),
+    style: z.number().int().min(0).max(50),
 }).strict();
-// Reviewer stages add verdict + round + concern categories.
-export const ReviewStageStats = StageStats.extend({
-    verdict: z
-        .enum(['approved', 'concerns', 'changes_required', 'error', 'skipped', 'not_applicable'])
-        .nullable(),
-    roundsUsed: z.enum(['0', '1', '2+']).nullable(),
-    concernCategories: z
-        .array(ConcernCategory)
-        .max(9)
-        .nullable(), // categorized server-side; never raw text. Cap matches the ConcernCategory enum cardinality so a stage that surfaced every distinct category isn't silently truncated.
+// ── Stage entry (§3.3) ───────────────────────────────────────────────────
+const StageNameEnum = z.enum([
+    'implementing',
+    'spec_review',
+    'spec_rework',
+    'quality_review',
+    'quality_rework',
+    'diff_review',
+    'verifying',
+    'committing',
+]);
+// Base fields shared by all stage variants
+const StageEntryBase = z.object({
+    name: StageNameEnum,
+    model: z.string().regex(STRICT_ID_REGEX),
+    agentTier: z.enum(['standard', 'reasoning']),
+    durationMs: z.number().int().min(0).max(3_600_000),
+    costUSD: z.number().min(0).max(100),
+    inputTokens: z.number().int().min(0).max(5_000_000),
+    outputTokens: z.number().int().min(0).max(500_000),
+    cachedTokens: z.number().int().min(0).max(5_000_000),
+    reasoningTokens: z.number().int().min(0).max(500_000),
+    toolCallCount: z.number().int().min(0).max(5000),
+    filesReadCount: z.number().int().min(0).max(5000),
+    filesWrittenCount: z.number().int().min(0).max(5000),
+    turnCount: z.number().int().min(0).max(250),
+    maxIdleMs: z.number().int().min(0).max(1_200_000).nullable(),
+    totalIdleMs: z.number().int().min(0).max(3_600_000).nullable(),
 });
-// Verify stage adds outcome + skip reason.
-export const VerifyStageStats = StageStats.extend({
-    outcome: z.enum(['passed', 'failed', 'skipped', 'not_applicable']).nullable(),
+export const ReviewStageEntrySchema = StageEntryBase.extend({
+    name: z.enum(['spec_review', 'quality_review', 'diff_review']),
+    verdict: z.enum(['approved', 'concerns', 'changes_required', 'error', 'skipped', 'annotated', 'not_applicable']),
+    roundsUsed: z.number().int().min(1).max(10),
+    concernCategories: z.array(ConcernCategory).max(9),
+    findingsBySeverity: FindingsBySeveritySchema,
+}).strict();
+export const ReworkStageEntrySchema = StageEntryBase.extend({
+    name: z.enum(['spec_rework', 'quality_rework']),
+    triggeringConcernCategories: z.array(ConcernCategory).max(9),
+}).strict();
+export const VerifyStageEntrySchema = StageEntryBase.extend({
+    name: z.literal('verifying'),
+    outcome: z.enum(['passed', 'failed', 'skipped', 'not_applicable']),
     skipReason: z.enum(['no_command', 'dirty_worktree', 'not_applicable', 'other']).nullable(),
-});
-export const TaskCompletedEvent = z.object({
-    type: z.literal('task.completed'),
-    // Route shape
-    route: z.enum(['delegate', 'audit', 'review', 'verify', 'debug', 'execute-plan', 'retry']),
+}).strict();
+export const CommitStageEntrySchema = StageEntryBase.extend({
+    name: z.literal('committing'),
+    filesCommittedCount: z.number().int().min(0).max(1000),
+    branchCreated: z.boolean(),
+}).strict();
+export const ImplementStageEntrySchema = StageEntryBase.extend({
+    name: z.literal('implementing'),
+}).strict();
+export const StageEntrySchema = z.discriminatedUnion('name', [
+    ImplementStageEntrySchema,
+    ReviewStageEntrySchema,
+    ReworkStageEntrySchema,
+    VerifyStageEntrySchema,
+    CommitStageEntrySchema,
+]);
+// ── Task completed event (§3.2) ──────────────────────────────────────────
+export const TaskCompletedEventSchema = z.object({
+    // Identity
+    eventId: z.string().uuid(),
+    route: z.enum(['delegate', 'audit', 'review', 'verify', 'debug', 'execute-plan', 'retry', 'investigate']),
+    client: z.string().regex(STRICT_ID_REGEX),
+    // Configuration
     agentType: z.enum(['standard', 'complex']),
-    capabilities: z
-        .array(z.enum(['web_search', 'web_fetch', 'other']))
-        .max(3)
-        .refine(xs => new Set(xs).size === xs.length, 'unique'),
     toolMode: z.enum(['none', 'readonly', 'no-shell', 'full']),
-    triggeredFromSkill: BoundedIdentifier, // 'direct' for non-skill invocations
-    client: ClientId, // which agent client invoked us
-    // Task shape (derived from structured task metadata; never from prompt parsing or fs scanning)
-    fileCountBucket: z.enum(['0', '1-5', '6-20', '21-50', '51+']),
-    durationBucket: z.enum(['<10s', '10s-1m', '1m-5m', '5m-30m', '30m+']),
-    costBucket: z.enum(['$0', '<$0.01', '$0.01-$0.10', '$0.10-$1', '$1+']),
-    savedCostBucket: z.enum(['$0', '<$0.10', '$0.10-$1', '$1+', 'unknown']),
-    // Implementer model summary (top-level convenience; per-stage detail lives in `stages`)
-    implementerModelFamily: ModelFamily,
-    implementerModel: BoundedIdentifier,
+    capabilities: z.array(z.enum(['web_search', 'web_fetch', 'other'])).max(3),
+    reviewPolicy: z.enum(['full', 'quality_only', 'diff_only', 'none']),
+    verifyCommandPresent: z.boolean(),
+    // Model
+    implementerModel: z.string().regex(STRICT_ID_REGEX),
     // Outcome
-    terminalStatus: z.enum([
-        'ok',
-        'incomplete',
-        'timeout',
-        'error',
-        'cost_exceeded',
-        'brief_too_vague',
-        'unavailable',
-    ]),
-    workerStatus: z.enum([
-        'done',
-        'done_with_concerns',
-        'needs_context',
-        'blocked',
-        'failed',
-        'review_loop_aborted',
-    ]),
-    errorCode: ErrorCode.nullable(), // populated when terminalStatus is a failure mode
-    // 3.5.0 lifecycle effectiveness
-    escalated: z.boolean(),
-    fallbackTriggered: z.boolean(),
-    // Tool-call profile — top 5 distinct tool names called during this task by count
-    // (allowlisted; non-listed tools become 'other'; never includes args/paths)
-    topToolNames: z.array(BoundedIdentifier).max(20),
-    // Per-stage breakdown — drives the lifecycle funnel + per-stage panels
-    stages: z.object({
-        implementing: StageStats,
-        verifying: VerifyStageStats,
-        spec_review: ReviewStageStats,
-        spec_rework: StageStats, // implementer re-runs after spec changes_required
-        quality_review: ReviewStageStats,
-        quality_rework: StageStats,
-        diff_review: ReviewStageStats.optional(), // diff-only policy; not always present
-        committing: StageStats,
-    }).strict(),
-    // v2 fields
-    filesWrittenBucket: z.enum(['0', '1-5', '6-20', '21-50', '51+']),
-    c2Promoted: z.boolean(),
-    workerSelfAssessment: z.enum(['done', 'done_with_concerns', 'needs_context', 'blocked', 'failed', 'review_loop_aborted']).nullable(),
-    concernCount: z.number().int().min(0).max(50),
+    terminalStatus: z.enum(['ok', 'incomplete', 'timeout', 'error', 'cost_exceeded', 'brief_too_vague', 'unavailable']),
+    workerStatus: z.enum(['done', 'done_with_concerns', 'needs_context', 'blocked', 'failed', 'review_loop_aborted']),
+    errorCode: ErrorCode.nullable(),
+    parentModelFamily: ModelFamilyEnum,
+    // Token economics
+    inputTokens: z.number().int().min(0).max(5_000_000),
+    outputTokens: z.number().int().min(0).max(500_000),
+    cachedTokens: z.number().int().min(0).max(5_000_000),
+    reasoningTokens: z.number().int().min(0).max(500_000),
+    // Run totals
+    totalDurationMs: z.number().int().min(0).max(86_400_000),
+    totalCostUSD: z.number().min(0).max(800),
+    totalSavedCostUSD: z.number().min(-800).max(800).nullable(),
+    // Lifecycle counts
+    concernCount: z.number().int().min(0).max(150),
     escalationCount: z.number().int().min(0).max(20),
     fallbackCount: z.number().int().min(0).max(20),
-    turnCountBucket: z.enum(['1-3', '4-10', '11-30', '31+']),
-    stallTriggered: z.boolean(),
+    // Operational signals
+    stallCount: z.number().int().min(0).max(20),
+    taskMaxIdleMs: z.number().int().min(0).max(1_200_000).nullable(),
     clarificationRequested: z.boolean(),
-    parentModelFamily: ModelFamily,
-    briefQualityWarningCount: z.number().int().min(0).max(10),
-}).strict();
-export const SessionStartedEvent = z.object({
-    type: z.literal('session.started'),
-    configFlavor: z.object({
-        defaultTier: z.enum(['standard', 'complex']),
-        diagnosticsEnabled: z.boolean(),
-        autoUpdateSkills: z.boolean(),
-    }).strict(),
-    providersConfigured: z
-        .array(z.enum(['claude', 'openai-compatible', 'codex']))
-        .max(3)
-        .refine(xs => new Set(xs).size === xs.length, 'unique'),
-}).strict();
-export const InstallChangedEvent = z.object({
-    type: z.literal('install.changed'),
-    fromVersion: VersionString.nullable(),
-    toVersion: VersionString,
-    trigger: z.enum(['fresh_install', 'upgrade', 'downgrade']),
+    briefQualityWarningCount: z.number().int().min(0).max(20),
+    sandboxViolationCount: z.number().int().min(0).max(100),
+    // Stages array
+    stages: z.array(StageEntrySchema).min(0).max(8),
 }).strict();
-export const SkillInstalledEvent = z.object({
-    type: z.literal('skill.installed'),
-    skill: InstallableSkillId, // 'direct' is NOT a skill, rejected here
-    client: ClientId,
+// ── Upload batch ─────────────────────────────────────────────────────────
+export const UploadBatchSchema = z.object({
+    schemaVersion: z.literal(3),
+    installId: z.string().uuid(),
+    mmagentVersion: VersionString,
+    os: Os,
+    nodeMajor: z.number().int().min(22).max(99),
+    events: z.array(TaskCompletedEventSchema).min(1).max(500),
 }).strict();
-// Discriminated union, with eventId for at-most-once dedup within retention window.
-// .superRefine() enforces internal consistency (see 4.4 for the rules).
-const TelemetryEventBase = z.object({ eventId: z.string().uuid() }).strict();
-export const TelemetryEvent = z
-    .discriminatedUnion('type', [
-    TaskCompletedEvent.merge(TelemetryEventBase),
-    SessionStartedEvent.merge(TelemetryEventBase),
-    InstallChangedEvent.merge(TelemetryEventBase),
-    SkillInstalledEvent.merge(TelemetryEventBase),
-])
-    .superRefine((event, ctx) => {
-    if (event.type !== 'task.completed')
-        return;
+// ── Super-refinement: R1–R15 (§3.4) ──────────────────────────────────────
+const qualityOnlyRoutes = new Set(['audit', 'review', 'verify', 'debug', 'investigate']);
+const reviewedRoutes = new Set(['delegate', 'audit', 'review', 'verify', 'debug', 'execute-plan', 'investigate']);
+const reworkStages = new Set(['spec_rework', 'quality_rework']);
+const reviewStages = new Set(['spec_review', 'quality_review', 'diff_review']);
+export const ValidatedTaskCompletedEventSchema = TaskCompletedEventSchema.superRefine((event, ctx) => {
     // R1: ok terminalStatus implies non-failed worker outcome and no errorCode
     if (event.terminalStatus === 'ok') {
         if (!['done', 'done_with_concerns'].includes(event.workerStatus)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: 'terminalStatus=ok requires workerStatus done|done_with_concerns',
-            });
+            ctx.addIssue({ code: 'custom', message: 'R1: terminalStatus=ok requires workerStatus done|done_with_concerns' });
         }
         if (event.errorCode !== null) {
-            ctx.addIssue({
-                code: 'custom',
-                message: 'terminalStatus=ok requires errorCode=null',
-            });
+            ctx.addIssue({ code: 'custom', message: 'R1: terminalStatus=ok requires errorCode=null' });
         }
     }
-    // R2: verify only applies to routes that exercise the verify stage
-    const verifyApplicableRoutes = new Set(['delegate', 'execute-plan', 'verify']);
-    const verifyOutcome = event.stages.verifying.outcome;
-    if (!verifyApplicableRoutes.has(event.route) &&
-        verifyOutcome !== null &&
-        verifyOutcome !== 'not_applicable') {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'stages.verifying.outcome must be null or not_applicable for non-verify routes',
-        });
+    // R2: stage count must be > 0 for ok/incomplete (brief_too_vague may have 0)
+    // R2.1: empty stages only allowed for brief_too_vague and error
+    if (event.stages.length === 0 && !['brief_too_vague', 'error'].includes(event.terminalStatus)) {
+        ctx.addIssue({ code: 'custom', message: 'R2.1: empty stages only allowed for brief_too_vague|error' });
     }
-    // R3: spec/quality/diff review only on routes that go through the reviewed lifecycle
-    const reviewedRoutes = new Set(['delegate', 'execute-plan']);
-    if (!reviewedRoutes.has(event.route)) {
-        if (event.stages.spec_review.entered) {
-            ctx.addIssue({
-                code: 'custom',
-                message: 'stages.spec_review.entered must be false for non-reviewed routes',
-            });
-        }
-        if (event.stages.quality_review.entered) {
-            ctx.addIssue({
-                code: 'custom',
-                message: 'stages.quality_review.entered must be false for non-reviewed routes',
-            });
-        }
-        if (event.stages.diff_review?.entered) {
-            ctx.addIssue({
-                code: 'custom',
-                message: 'stages.diff_review.entered must be false (or stages.diff_review absent) for non-reviewed routes',
-            });
-        }
+    // R3: concernCount must not exceed the sum of findingsBySeverity bins + a tolerance
+    // Per plan Task 6, concernCount is capped separately; the invariant is sum(bins) ≤ concernCount
+    // R4: totalDurationMs >= sum of stage durationMs (not strictly equal due to overhead)
+    const stageDurationSum = event.stages.reduce((s, st) => s + st.durationMs, 0);
+    if (stageDurationSum > event.totalDurationMs) {
+        ctx.addIssue({ code: 'custom', message: 'R4: sum of stage durationMs must not exceed totalDurationMs' });
     }
-    // R4: stage sub-fields must be null when entered=false
-    // (`stages.diff_review` is `.optional()` and is omitted from the parsed
-    // object entirely when absent — Object.entries doesn't surface it as
-    // `[name, undefined]`. The `!st` guard is defensive belt-and-suspenders
-    // that also covers the case where a future schema change makes the
-    // field nullable rather than optional.)
-    for (const [name, st] of Object.entries(event.stages)) {
-        if (!st)
-            continue;
-        if (!st.entered) {
-            // All five `StageStats` nullable fields must be null when the stage was not entered.
-            const baseDirty = st.durationBucket !== null ||
-                st.costBucket !== null ||
-                st.agentTier !== null ||
-                st.modelFamily !== null ||
-                st.model !== null;
-            // Extended fields on review / verify stages must also be null when entered=false.
-            const reviewDirty = ('verdict' in st && st.verdict !== null) ||
-                ('roundsUsed' in st && st.roundsUsed !== null) ||
-                ('concernCategories' in st &&
-                    st.concernCategories !== null);
-            const verifyDirty = ('outcome' in st && st.outcome !== null) ||
-                ('skipReason' in st && st.skipReason !== null);
-            if (baseDirty || reviewDirty || verifyDirty) {
-                ctx.addIssue({
-                    code: 'custom',
-                    message: `stages.${name} sub-fields must be null when entered=false`,
-                });
-            }
+    // R5: top-level token counts = sum of stage token counts
+    const tokenSum = event.stages.reduce((acc, st) => ({
+        input: acc.input + st.inputTokens,
+        output: acc.output + st.outputTokens,
+        cached: acc.cached + st.cachedTokens,
+        reasoning: acc.reasoning + st.reasoningTokens,
+    }), { input: 0, output: 0, cached: 0, reasoning: 0 });
+    if (tokenSum.input !== event.inputTokens ||
+        tokenSum.output !== event.outputTokens ||
+        tokenSum.cached !== event.cachedTokens ||
+        tokenSum.reasoning !== event.reasoningTokens) {
+        ctx.addIssue({ code: 'custom', message: 'R5: token sums must equal top-level totals' });
+    }
+    // R5b: per stage, reasoningTokens ≤ outputTokens (subset semantics)
+    for (const st of event.stages) {
+        if (st.reasoningTokens > st.outputTokens) {
+            ctx.addIssue({ code: 'custom', message: 'R5b: reasoningTokens must not exceed outputTokens per stage' });
         }
     }
-    // R5: when entered=true, the base bucketed fields plus the stage-type-specific
-    // fields must be non-null (the stage actually ran, so it produced cost/duration
-    // and a verdict/outcome). `skipReason` is exempt — it is legitimately null
-    // unless `outcome === 'skipped'`. `concernCategories` is exempt — a clean
-    // verdict legitimately surfaces an empty list.
-    for (const [name, st] of Object.entries(event.stages)) {
-        if (!st || !st.entered)
-            continue;
-        const baseMissing = st.durationBucket === null ||
-            st.costBucket === null ||
-            st.agentTier === null ||
-            st.modelFamily === null ||
-            st.model === null;
-        if (baseMissing) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `stages.${name} base sub-fields must be non-null when entered=true`,
-            });
+    // R6: per stage, cachedTokens ≤ inputTokens (cached is subset of input)
+    for (const st of event.stages) {
+        if (st.cachedTokens > st.inputTokens) {
+            ctx.addIssue({ code: 'custom', message: 'R6: cachedTokens must not exceed inputTokens per stage' });
         }
-        if ('verdict' in st && st.verdict === null) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `stages.${name}.verdict must be non-null when entered=true`,
-            });
+    }
+    // R7: totalCostUSD = sum of stage costUSD (float comparison with tolerance)
+    const costSum = event.stages.reduce((s, st) => s + st.costUSD, 0);
+    if (Math.abs(costSum - event.totalCostUSD) > 0.02) {
+        ctx.addIssue({ code: 'custom', message: 'R7: totalCostUSD must approximately equal sum of stage costUSD' });
+    }
+    // R8: verification outcome only on delegate, execute-plan, verify routes
+    const verifyRoutes = new Set(['delegate', 'execute-plan', 'verify']);
+    for (const st of event.stages) {
+        if (st.name === 'verifying' && !verifyRoutes.has(event.route)) {
+            ctx.addIssue({ code: 'custom', message: 'R8: verifying stage only allowed on delegate|execute-plan|verify routes' });
         }
-        if ('roundsUsed' in st && st.roundsUsed === null) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `stages.${name}.roundsUsed must be non-null when entered=true`,
-            });
+    }
+    // R9: review stages only on reviewed routes
+    for (const st of event.stages) {
+        if (reviewStages.has(st.name) && !reviewedRoutes.has(event.route)) {
+            ctx.addIssue({ code: 'custom', message: `R9: ${st.name} stage only allowed on reviewed routes` });
         }
-        if ('outcome' in st && st.outcome === null) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `stages.${name}.outcome must be non-null when entered=true`,
-            });
+    }
+    // R10: quality_only routes must not have spec_review, diff_review, or rework stages
+    // R10b: no rework on quality_only
+    // R10c: annotated verdict only on quality_only routes
+    for (const st of event.stages) {
+        if (qualityOnlyRoutes.has(event.route)) {
+            if (reviewStages.has(st.name) && st.name !== 'quality_review') {
+                ctx.addIssue({ code: 'custom', message: 'R10: non-quality review stage on quality_only route' });
+            }
+            if (reworkStages.has(st.name)) {
+                ctx.addIssue({ code: 'custom', message: 'R10b: rework stages not allowed on quality_only routes' });
+            }
         }
-        if ('outcome' in st &&
-            st.outcome === 'skipped' &&
-            st.skipReason === null) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `stages.${name}.skipReason must be non-null when outcome='skipped'`,
-            });
+        if ('verdict' in st && st.verdict === 'annotated' && !qualityOnlyRoutes.has(event.route)) {
+            ctx.addIssue({ code: 'custom', message: 'R10c: annotated verdict only allowed on quality_only routes' });
         }
     }
+    // R11: concernCount in [0, 150], escalationCount in [0, 20], fallbackCount in [0, 20]
+    // (enforced by Zod schema bounds)
+    // R12: stallCount in [0, 20], sandboxViolationCount in [0, 100]
+    // (enforced by Zod schema bounds)
+    // R13: totalDurationMs in [0, 86_400_000]
+    // (enforced by Zod schema bounds)
+    // R14: totalCostUSD in [0, 800], totalSavedCostUSD in [-800, 800] or null
+    // (enforced by Zod schema bounds)
+    // R15: costUSD per stage in [0, 100]
+    // (enforced by Zod schema bounds)
 });
-// The complete uploadable envelope.
-export const UploadBatch = z.object({
-    schemaVersion: z.literal(SCHEMA_VERSION),
-    install: InstallMetadata,
-    events: z.array(TelemetryEvent).min(1).max(500),
-}).strict();
 //# sourceMappingURL=types.js.map