openmerit 0.1.5 → 0.1.6-preview.0

package/dist/pi/src/scheduler.d.ts

@@ -0,0 +1,11 @@
+export interface PiWakeupOptions {
+    readonly projectRoot: string;
+    readonly extensionPath: string;
+    readonly provider: string;
+    readonly modelId: string;
+}
+export declare function piWakeupLabel(projectRoot: string): string;
+export declare function piWakeupPlistPath(projectRoot: string): string;
+export declare function renderPiWakeupPlist(options: PiWakeupOptions, piPath: string, runnerPath: string): string;
+export declare function provisionPiWakeup(options: PiWakeupOptions): Promise<string>;
+export declare function removePiWakeup(projectRoot: string): Promise<boolean>;

package/dist/pi/src/scheduler.js

@@ -0,0 +1,137 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const POLL_SECONDS = 300;
+function projectHash(projectRoot) {
+    return createHash("sha256").update(resolve(projectRoot)).digest("hex").slice(0, 16);
+}
+export function piWakeupLabel(projectRoot) {
+    return `com.openmerit.pi.${projectHash(projectRoot)}`;
+}
+export function piWakeupPlistPath(projectRoot) {
+    return join(homedir(), "Library", "LaunchAgents", `${piWakeupLabel(projectRoot)}.plist`);
+}
+function managedMarker(projectRoot) {
+    return `<!-- openmerit-managed:${projectHash(projectRoot)} -->`;
+}
+function xml(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+async function executable(name) {
+    for (const directory of (process.env.PATH ?? "").split(":")) {
+        if (!directory)
+            continue;
+        const path = join(directory, name);
+        try {
+            await access(path, constants.X_OK);
+            return path;
+        }
+        catch { /* try the next PATH entry */ }
+    }
+    throw new Error(`${name} is not on PATH`);
+}
+export function renderPiWakeupPlist(options, piPath, runnerPath) {
+    const args = [process.execPath, runnerPath, resolve(options.projectRoot), piPath,
+        resolve(options.extensionPath), options.provider, options.modelId];
+    const argumentsXml = args.map((argument) => `      <string>${xml(argument)}</string>`).join("\n");
+    const path = [dirname(process.execPath), dirname(piPath), "/usr/bin", "/bin", "/usr/sbin", "/sbin"].join(":");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+${managedMarker(options.projectRoot)}
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${xml(piWakeupLabel(options.projectRoot))}</string>
+  <key>ProgramArguments</key><array>
+${argumentsXml}
+  </array>
+  <key>WorkingDirectory</key><string>${xml(resolve(options.projectRoot))}</string>
+  <key>EnvironmentVariables</key><dict>
+    <key>PATH</key><string>${xml(path)}</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>StartInterval</key><integer>${POLL_SECONDS}</integer>
+</dict>
+</plist>
+`;
+}
+async function loaded(label) {
+    try {
+        await execFileAsync("launchctl", ["print", `gui/${process.getuid?.()}/${label}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function provisionPiWakeup(options) {
+    if (process.platform !== "darwin" || process.getuid === undefined) {
+        throw new Error("Persistent Pi wakeups require a macOS user LaunchAgent.");
+    }
+    if (!options.provider || !options.modelId)
+        throw new Error("Select an authenticated Pi model before scheduling.");
+    const piPath = await executable("pi");
+    const auth = await execFileAsync(piPath, ["auth", "check", "--model", `${options.provider}/${options.modelId}`], {
+        env: {
+            HOME: homedir(),
+            PATH: [dirname(process.execPath), dirname(piPath), "/usr/bin", "/bin", "/usr/sbin", "/sbin"].join(":"),
+        },
+    });
+    if (auth.stdout.trim() !== "ready") {
+        throw new Error(`Pi authentication is not ready for ${options.provider}/${options.modelId} in the background environment.`);
+    }
+    const extensionPath = resolve(options.extensionPath);
+    const runnerPath = join(dirname(extensionPath), `wakeup${extname(extensionPath)}`);
+    await access(runnerPath, constants.R_OK);
+    const path = piWakeupPlistPath(options.projectRoot);
+    const content = renderPiWakeupPlist({ ...options, extensionPath }, piPath, runnerPath);
+    let prior;
+    try {
+        prior = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (prior && !prior.includes(managedMarker(options.projectRoot))) {
+        throw new Error(`Refusing to replace unmanaged LaunchAgent ${basename(path)}.`);
+    }
+    const label = piWakeupLabel(options.projectRoot);
+    if (prior === content && await loaded(label))
+        return path;
+    if (await loaded(label))
+        await execFileAsync("launchctl", ["bootout", `gui/${process.getuid()}/${label}`]);
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, content, { mode: 0o600 });
+    await rename(temporary, path);
+    await execFileAsync("launchctl", ["bootstrap", `gui/${process.getuid()}`, path]);
+    return path;
+}
+export async function removePiWakeup(projectRoot) {
+    if (process.platform !== "darwin" || process.getuid === undefined)
+        return false;
+    const path = piWakeupPlistPath(projectRoot);
+    let content;
+    try {
+        content = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+    if (!content.includes(managedMarker(projectRoot))) {
+        throw new Error(`Refusing to remove unmanaged LaunchAgent ${basename(path)}.`);
+    }
+    const label = piWakeupLabel(projectRoot);
+    if (await loaded(label))
+        await execFileAsync("launchctl", ["bootout", `gui/${process.getuid()}/${label}`]);
+    await unlink(path);
+    return true;
+}

package/dist/pi/src/wakeup.d.ts

@@ -0,0 +1,2 @@
+import type { OpenMeritProjectState } from "../../protocol/src/index.ts";
+export declare function isPiWakeupDue(state: OpenMeritProjectState, now?: string): boolean;

package/dist/pi/src/wakeup.js

@@ -0,0 +1,108 @@
+import { spawn } from "node:child_process";
+import { writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildAutomationPlan, OpenMeritCoordinator, ProjectStore } from "../../core/src/index.js";
+const wakeupDescriptor = {
+    id: "pi-launchagent", name: "Pi LaunchAgent", version: "0.87", protocolVersions: ["0.1"],
+    capabilities: [], executionModes: ["non_interactive"],
+    structuredOutput: { schemaDialect: "https://json-schema.org/draft/2020-12/schema", presentation: "adapter_validation", enforcement: "adapter" },
+    automation: {
+        supportedSignals: ["product_task_completed", "metric_window_available", "scheduled_tick", "model_catalog_changed", "verification_window_completed"],
+        persistentScheduling: true, backgroundExecution: true, wakeupProvisioning: "infrastructure_change",
+    },
+};
+export function isPiWakeupDue(state, now = new Date().toISOString()) {
+    const execution = state.cycle.policy?.checkPolicy.execution;
+    if (execution?.mode !== "persistent" || !execution.infrastructureChangesAllowed || state.activeIntent || state.automation.paused)
+        return false;
+    if (state.automation.pendingIntentKind)
+        return true;
+    const at = buildAutomationPlan(state, wakeupDescriptor).nextWakeupAt;
+    return at !== undefined && Date.parse(at) <= Date.parse(now);
+}
+async function run() {
+    const [projectRoot, piPath, extensionPath, provider, modelId] = process.argv.slice(2);
+    if (!projectRoot || !piPath || !extensionPath || !provider || !modelId)
+        process.exitCode = 2;
+    if (process.exitCode)
+        return;
+    const store = new ProjectStore(projectRoot);
+    const state = await store.readState();
+    if (!state || !isPiWakeupDue(state))
+        return;
+    const startedAt = new Date().toISOString();
+    const coordinator = new OpenMeritCoordinator(store, {
+        descriptor: wakeupDescriptor,
+        async dispatch() { return { accepted: false, reason: "The wakeup runner does not dispatch harness work directly." }; },
+    });
+    const check = state.automation.pendingIntentKind === "run_assessment"
+        ? await coordinator.assessBaseline(startedAt)
+        : state.automation.pendingIntentKind
+            ? undefined
+            : await coordinator.recordAutomationSignal({
+                protocolVersion: "0.1", id: `wakeup-${crypto.randomUUID()}`,
+                type: "scheduled_tick", occurredAt: startedAt, targetId: state.cycle.targetId,
+            });
+    if (check && check.decision.action !== "issue_intent") {
+        await writeFile(join(store.directory, "scheduler-status.json"), JSON.stringify({
+            schemaVersion: 1, startedAt, completedAt: new Date().toISOString(), exitCode: 0,
+            decision: check.decision.reason,
+        }, null, 2) + "\n", { mode: 0o600 });
+        return;
+    }
+    const configuredTimeout = Number(process.env.OPENMERIT_WAKEUP_TIMEOUT_MS);
+    const runLimitMs = Number.isFinite(configuredTimeout) && configuredTimeout >= 5_000
+        ? Math.min(configuredTimeout, 15 * 60_000)
+        : 15 * 60_000;
+    const deadline = Date.now() + runLimitMs;
+    const invokePi = async (prompt) => {
+        const child = spawn(piPath, [
+            "--no-extensions", "--extension", extensionPath, "--provider", provider, "--model", modelId,
+            ...(process.env.OPENMERIT_WAKEUP_DEBUG === "1" ? ["--mode", "json"] : []),
+            "--no-session", "--print", prompt,
+        ], { cwd: projectRoot, stdio: process.env.OPENMERIT_WAKEUP_DEBUG === "1" ? "inherit" : "ignore", env: process.env });
+        return new Promise((resolve, reject) => {
+            let timedOut = false;
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+                setTimeout(() => child.kill("SIGKILL"), 5_000).unref();
+            }, Math.max(1, deadline - Date.now()));
+            child.once("error", (error) => { clearTimeout(timeout); reject(error); });
+            child.once("exit", (code) => { clearTimeout(timeout); resolve(timedOut ? 124 : code ?? 1); });
+        });
+    };
+    let exitCode = await invokePi("Run the due OpenMerit scheduled check for this configured project. " +
+        "On startup, OpenMerit may create an active intent in .openmerit/state.json. Read that intent and .openmerit/config.json, " +
+        "perform only its authorized work, and call openmerit_complete_intent exactly once with verified evidence. " +
+        "For baseline assessment, if no application metric windows exist, report insufficiency promptly; do not wait for new data or invent samples. " +
+        "If evidence is unavailable, report failure honestly. Never change Pi's model or an unauthorized application route.");
+    const issued = await store.readState();
+    if (exitCode === 0 && issued?.activeIntent && !state.activeIntent && Date.now() < deadline) {
+        const intent = issued.activeIntent;
+        exitCode = await invokePi(`Complete the already active OpenMerit ${intent.kind} intent ${intent.id}. ` +
+            "Read .openmerit/config.json and the project evidence. Follow the requested outcome and constraints below. " +
+            "Use the registered openmerit_complete_intent tool exactly once, with verified evidence; if evidence is unavailable, report failure honestly. " +
+            "Never change Pi's model or the application model unless this intent explicitly authorizes that target-bound change.\n\n" +
+            JSON.stringify(intent));
+        if ((await store.readState())?.activeIntent?.id === intent.id)
+            exitCode = 1;
+    }
+    const finalState = await store.readState();
+    if (finalState?.activeIntent && exitCode === 0)
+        exitCode = 1;
+    if (finalState?.automation.pendingIntentKind && exitCode === 0)
+        exitCode = 1;
+    await writeFile(join(store.directory, "scheduler-status.json"), JSON.stringify({
+        schemaVersion: 1, startedAt, completedAt: new Date().toISOString(), exitCode,
+        ...(finalState?.activeIntent ? { activeIntentId: finalState.activeIntent.id } : {}),
+    }, null, 2) + "\n", { mode: 0o600 });
+    process.exitCode = exitCode;
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+    run().catch((error) => {
+        process.stderr.write(`OpenMerit Pi wakeup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/protocol/src/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PROTOCOL_VERSION: "0.1";
-export { CandidateAssessmentSchema, CandidateDescriptorSchema, completionToolSchemaFor, EvidenceReferenceSchema, FrontierRecommendationSchema, FrontierSnapshotSchema, INTENT_OUTPUT_SCHEMAS, intentOutputSchemaFor, MetricObjectiveSchema, MetricRecordSchema, ObservabilityCoverageSchema, OPENMERIT_RESULT_SCHEMA_VERSION, OPENMERIT_SCHEMA_DIALECT, SupervisedGraduationPolicySchema, TaskProfileSchema, validateIntentOutputSchema, } from "./schemas.ts";
+export { ApplicationLlmTargetSchema, CandidateAssessmentSchema, CandidateDescriptorSchema, completionToolSchemaFor, EvidenceReferenceSchema, FrontierRecommendationSchema, FrontierSnapshotSchema, INTENT_OUTPUT_SCHEMAS, intentOutputSchemaFor, MetricObjectiveSchema, MetricRecordSchema, ObservabilityCoverageSchema, OPENMERIT_RESULT_SCHEMA_VERSION, OPENMERIT_SCHEMA_DIALECT, SupervisedGraduationPolicySchema, TaskProfileSchema, validateIntentOutputSchema, } from "./schemas.ts";
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | {
     readonly [key: string]: JsonValue;
@@ -88,6 +88,7 @@ export interface OpenMeritIntent {
     readonly protocolVersion: typeof PROTOCOL_VERSION;
     readonly id: string;
     readonly kind: IntentKind;
+    readonly targetId?: string;
     readonly taskProfileId: string;
     readonly authorizationPolicyId: string;
     readonly requestedOutcome: string;
@@ -161,11 +162,13 @@ export interface MetricDefinition {
 }
 export declare const METRIC_CATALOG: readonly MetricDefinition[];
 export interface MetricRecord {
+    readonly targetId: string;
     readonly metricId: MetricId;
     readonly state: MetricState;
     readonly scope: MetricScope;
     readonly direction: MetricDirection;
     readonly method: MeasurementMethod;
+    readonly aggregation: "single_value" | "sum" | "mean" | "rate" | "distribution" | "percentile";
     readonly value?: number;
     readonly unit: string;
     readonly sampleCount: number;
@@ -186,22 +189,41 @@ export interface MetricObjective {
     readonly required: boolean;
     readonly minimumSamples: number;
     readonly tolerance: number;
+    readonly samplingPlan: {
+        readonly strategy: "single_run" | "repeated_same_input" | "representative_task_set" | "repeated_representative_task_set" | "load_test";
+        readonly representativeCaseCount: number;
+        readonly repetitionsPerCase: number;
+        readonly aggregation: "single_value" | "mean" | "rate" | "distribution" | "percentile";
+        readonly rationale: string;
+    };
     readonly constraint?: {
         readonly operator: "at_least" | "at_most";
         readonly value: number;
     };
 }
+/** A user-confirmed application LLM route. The coding harness itself is never an evaluation target. */
+export interface ApplicationLlmTarget {
+    readonly id: string;
+    readonly kind: "application_llm_call";
+    readonly name: string;
+    readonly applicationId: string;
+    readonly callSites: readonly string[];
+    readonly routeKey: string;
+    readonly confirmedAt: string;
+}
 export interface TaskProfile {
     readonly id: string;
     readonly revision: number;
     readonly name: string;
     readonly goal: string;
+    readonly applicationTarget: ApplicationLlmTarget;
     readonly objectives: readonly MetricObjective[];
     readonly createdAt: string;
     readonly confirmedAt?: string;
 }
 export type ObservabilityReadinessStatus = "ready" | "incomplete";
 export interface ObservabilityCoverage {
+    readonly targetId: string;
     readonly status: ObservabilityReadinessStatus;
     readonly requiredMetricIds: readonly MetricId[];
     readonly coveredMetricIds: readonly MetricId[];
@@ -210,6 +232,7 @@ export interface ObservabilityCoverage {
 }
 export interface CandidateAssessment {
     readonly id: string;
+    readonly targetId: string;
     readonly taskProfileId: string;
     readonly taskProfileRevision: number;
     readonly candidateId: string;
@@ -230,6 +253,7 @@ export interface DominanceComparison {
 }
 export interface FrontierSnapshot {
     readonly id: string;
+    readonly targetId: string;
     readonly taskProfileId: string;
     readonly taskProfileRevision: number;
     readonly productRevision: string;
@@ -243,6 +267,7 @@ export interface FrontierSnapshot {
     readonly calculationEvidence: readonly EvidenceReference[];
 }
 export interface FrontierRecommendation {
+    readonly targetId: string;
     readonly frontierSnapshotId: string;
     readonly selectedCandidateId: string;
     readonly currentCandidateId: string;
@@ -250,50 +275,82 @@ export interface FrontierRecommendation {
     readonly preferenceEvidence: readonly EvidenceReference[];
 }
 export interface CandidateDescriptor {
+    readonly targetId: string;
     readonly candidateId: string;
     readonly modelId: string;
     readonly modelVersion?: string;
     readonly reasons: readonly string[];
 }
+/** Research priors only. These are never MetricRecords or frontier evidence. */
+export interface PreliminaryModelLead {
+    readonly targetId: string;
+    readonly modelId: string;
+    readonly modelVersion?: string;
+    readonly estimatedPrice: {
+        readonly currency: string;
+        readonly inputPerMillionTokens: number;
+        readonly outputPerMillionTokens: number;
+        readonly sourceUri: string;
+        readonly checkedAt: string;
+    };
+    readonly reputation: {
+        readonly summary: string;
+        readonly sourceUri: string;
+        readonly checkedAt: string;
+    };
+}
 export interface IntentOutputMap {
     readonly establish_evals: {
         readonly taskProfile: TaskProfile;
+        /** The application model configured before any challenger trial. */
+        readonly incumbent: CandidateDescriptor;
         readonly policy: SupervisedGraduationPolicy;
         readonly observability: ObservabilityCoverage;
+        readonly preliminaryModelLeads?: readonly PreliminaryModelLead[];
     };
     readonly instrument_observability: {
+        readonly targetId: string;
         readonly coveredMetricIds: readonly MetricId[];
         readonly missingMetricIds: readonly MetricId[];
     };
     readonly run_assessment: {
+        readonly targetId: string;
         readonly baselineEvidenceSufficient: boolean;
-        readonly metrics?: readonly MetricRecord[];
+        readonly metrics: readonly MetricRecord[];
     };
     readonly discover_candidates: {
+        readonly targetId: string;
         readonly candidates: readonly CandidateDescriptor[];
     };
     readonly run_challenger_trials: {
+        readonly targetId: string;
         readonly assessments: readonly CandidateAssessment[];
+        readonly experimentManifest: EvidenceReference;
     };
     readonly calculate_frontier: {
+        readonly targetId: string;
         readonly assessments: readonly CandidateAssessment[];
         readonly frontierSnapshot: FrontierSnapshot;
         readonly recommendation?: FrontierRecommendation;
     };
     readonly investigate_regression: {
+        readonly targetId: string;
         readonly regressionDetected: boolean;
         readonly affectedMetricIds: readonly MetricId[];
         readonly likelyCause?: string;
     };
     readonly apply_model_swap: {
+        readonly targetId: string;
         readonly appliedCandidateId: string;
         readonly previousCandidateId?: string;
     };
     readonly verify_model_swap: {
+        readonly targetId: string;
         readonly verified: boolean;
         readonly regressionDetected: boolean;
     };
     readonly rollback_model_swap: {
+        readonly targetId: string;
         readonly restoredCandidateId: string;
     };
 }
@@ -304,6 +361,7 @@ export declare const REQUIRED_CAPABILITIES: Readonly<Record<IntentKind, readonly
 export type ImprovementStage = "unconfigured" | "establishing_evidence" | "collecting_baseline" | "baseline_ready" | "discovering_candidates" | "candidates_ready" | "running_challenger_trials" | "challengers_ready" | "calculating_frontier" | "frontier_ready" | "awaiting_swap_approval" | "swap_approved" | "applying_swap" | "swap_applied" | "verifying_swap" | "swap_verified" | "verification_failed" | "rolling_back" | "monitoring";
 export interface ImprovementCycleState {
     readonly id: string;
+    readonly targetId?: string;
     readonly taskProfileId?: string;
     readonly stage: ImprovementStage;
     readonly activeCandidateId?: string;
@@ -319,14 +377,20 @@ export interface OpenMeritProjectConfig {
     readonly activeTaskProfileId?: string;
     readonly taskProfiles: readonly TaskProfile[];
     readonly policy?: SupervisedGraduationPolicy;
+    readonly preliminaryModelLeads?: readonly PreliminaryModelLead[];
 }
 export interface OpenMeritProjectState {
     readonly schemaVersion: 1;
     readonly cycle: ImprovementCycleState;
     readonly activeIntent?: OpenMeritIntent;
     readonly lastResult?: IntentResult;
+    /** Durable handoffs between discovery, trials, and frontier calculation. */
+    readonly candidates?: readonly CandidateDescriptor[];
+    readonly assessments?: readonly CandidateAssessment[];
+    readonly experimentManifest?: EvidenceReference;
     readonly observability?: ObservabilityCoverage;
     readonly automation: {
+        readonly paused?: boolean;
         readonly setupNudgeShown: boolean;
         readonly observedCompletedTasks: number;
         readonly lastAssessmentTaskCount: number;
@@ -336,6 +400,7 @@ export interface OpenMeritProjectState {
         readonly pendingIntentKind?: IntentKind;
         readonly pendingIntentReason?: string;
         readonly lastAssessmentAt?: string;
+        readonly baselineStartedAt?: string;
         readonly lastReassessmentTaskCount?: number;
         readonly lastReassessmentAt?: string;
         readonly lastRegressionCheckTaskCount?: number;
@@ -344,20 +409,37 @@ export interface OpenMeritProjectState {
         readonly swapAppliedAt?: string;
         readonly lastVerificationAt?: string;
         readonly latestMetricValues?: Readonly<Partial<Record<MetricId, number>>>;
+        /** Latest reported aggregate application-run window per metric; overlapping windows are never summed. */
+        readonly baselineMetricWindows?: readonly MetricRecord[];
+        /** Spend from controlled challenger trials; ordinary product work is excluded. */
+        readonly evaluationSpend?: number;
     };
     readonly updatedAt: string;
 }
-export type AuditEventType = "project_initialized" | "intent_requested" | "intent_progressed" | "intent_completed" | "requirements_confirmation_required" | "swap_confirmation_required" | "frontier_verified" | "frontier_rejected" | "cycle_advanced" | "setup_nudged" | "task_observed" | "model_catalog_changed" | "automation_signal_recorded" | "automation_signal_duplicate" | "automation_check_due" | "observability_readiness_checked";
+export type AuditEventType = "project_initialized" | "intent_requested" | "intent_progressed" | "intent_completed" | "requirements_confirmation_required" | "swap_confirmation_required" | "frontier_verified" | "frontier_rejected" | "cycle_advanced" | "setup_nudged" | "task_observed" | "model_catalog_changed" | "automation_signal_recorded" | "automation_signal_duplicate" | "automation_check_due" | "baseline_sufficiency_checked" | "observability_readiness_checked";
 interface AutomationSignalBase {
     readonly protocolVersion: typeof PROTOCOL_VERSION;
     readonly id: string;
     readonly occurredAt: string;
+    readonly targetId: string;
     readonly evidence?: readonly EvidenceReference[];
 }
 export type AutomationSignal = (AutomationSignalBase & {
     readonly type: "product_task_completed";
+    /** The model used by the application target, never the coding harness model. */
     readonly modelId: string;
-    readonly contextTokens?: number | null;
+    /** Provider telemetry captured from the application LLM call. */
+    readonly telemetry?: {
+        readonly startedAt: string;
+        readonly completedAt: string;
+        readonly durationMs: number;
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+        readonly cacheReadTokens: number;
+        readonly cacheWriteTokens: number;
+        readonly cost: number;
+        readonly currency: "USD";
+    };
 }) | (AutomationSignalBase & {
     readonly type: "metric_window_available";
     readonly metrics: readonly MetricRecord[];

package/dist/protocol/src/index.js

@@ -1,5 +1,5 @@
 export const PROTOCOL_VERSION = "0.1";
-export { CandidateAssessmentSchema, CandidateDescriptorSchema, completionToolSchemaFor, EvidenceReferenceSchema, FrontierRecommendationSchema, FrontierSnapshotSchema, INTENT_OUTPUT_SCHEMAS, intentOutputSchemaFor, MetricObjectiveSchema, MetricRecordSchema, ObservabilityCoverageSchema, OPENMERIT_RESULT_SCHEMA_VERSION, OPENMERIT_SCHEMA_DIALECT, SupervisedGraduationPolicySchema, TaskProfileSchema, validateIntentOutputSchema, } from "./schemas.js";
+export { ApplicationLlmTargetSchema, CandidateAssessmentSchema, CandidateDescriptorSchema, completionToolSchemaFor, EvidenceReferenceSchema, FrontierRecommendationSchema, FrontierSnapshotSchema, INTENT_OUTPUT_SCHEMAS, intentOutputSchemaFor, MetricObjectiveSchema, MetricRecordSchema, ObservabilityCoverageSchema, OPENMERIT_RESULT_SCHEMA_VERSION, OPENMERIT_SCHEMA_DIALECT, SupervisedGraduationPolicySchema, TaskProfileSchema, validateIntentOutputSchema, } from "./schemas.js";
 export const METRIC_CATALOG = [
     { id: "task_quality", label: "Task quality", direction: "maximize", defaultUnit: "score", requiresRepeatedRuns: false },
     { id: "task_success", label: "Task success rate", direction: "maximize", defaultUnit: "ratio", requiresRepeatedRuns: true },