catence 0.2.0-beta.9 → 0.2.0

package/dist/core/query/events.js

@@ -0,0 +1,121 @@
+const COURSE_ID_KEYS = ['courseId', 'course_id', 'courseID'];
+/** Pull a courseId from a Garmin/Intervals event/activity payload, tolerating the
+ * common key spellings and a nested `course.id` shape. Returns null when the
+ * payload carries no course reference rather than guessing. */
+export function extractCourseId(payload) {
+    let normalized = payload;
+    if (typeof payload === 'string') {
+        try {
+            normalized = JSON.parse(payload);
+        }
+        catch {
+            normalized = {};
+        }
+    }
+    const record = (typeof normalized === 'object' && normalized !== null && !Array.isArray(normalized)
+        ? normalized
+        : {});
+    for (const key of COURSE_ID_KEYS) {
+        const value = record[key];
+        if (typeof value === 'string' && value.length > 0)
+            return value;
+        if (typeof value === 'number' && Number.isFinite(value))
+            return String(value);
+    }
+    const nested = record.course;
+    if (nested !== null && typeof nested === 'object' && !Array.isArray(nested)) {
+        const nestedId = nested.id;
+        if (typeof nestedId === 'string' && nestedId.length > 0)
+            return nestedId;
+        if (typeof nestedId === 'number' && Number.isFinite(nestedId))
+            return String(nestedId);
+    }
+    return null;
+}
+export class EventsService {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    /** Resolve an event's referenced Garmin courseId and report whether its
+     * geometry has been synced. When geometry is absent, the result carries an
+     * explicit caveat so the agent never silently reuses a prior course profile. */
+    async resolveEventCourse(eventId) {
+        const caveats = [];
+        const events = await this.repository.rows(`SELECT provider, payload_json FROM source_entities
+       WHERE entity_type = 'event' AND remote_id = $eventId
+       ORDER BY provider = 'garmin' DESC, remote_id LIMIT 1`, { eventId });
+        if (events.length === 0) {
+            return {
+                eventId,
+                provider: null,
+                courseId: null,
+                courseSynced: false,
+                geometrySampleCount: 0,
+                caveats: [`No event source entity found for eventId ${eventId}.`],
+            };
+        }
+        const event = events[0];
+        const courseId = extractCourseId(event.payload_json);
+        if (courseId === null) {
+            return {
+                eventId,
+                provider: event.provider,
+                courseId: null,
+                courseSynced: false,
+                geometrySampleCount: 0,
+                caveats: [`Event ${eventId} does not reference a courseId; no course profile to resolve.`],
+            };
+        }
+        const synced = await this.repository.rows(`SELECT remote_id FROM source_entities
+       WHERE entity_type = 'course' AND remote_id = $courseId LIMIT 1`, { courseId });
+        const geometry = await this.repository.rows(`SELECT count(*) AS sample_count FROM course_geometry WHERE course_id = $courseId`, { courseId });
+        const geometrySampleCount = geometry.length > 0 ? Number(geometry[0].sample_count) : 0;
+        const courseSynced = synced.length > 0 && geometrySampleCount > 0;
+        if (!courseSynced) {
+            caveats.push(`Course geometry for courseId ${courseId} is not yet synced; this year's gradient is unverified until a recon run maps to that course. Do not reuse a prior course profile.`);
+        }
+        return {
+            eventId,
+            provider: event.provider,
+            courseId,
+            courseSynced,
+            geometrySampleCount,
+            caveats,
+        };
+    }
+    /** Compare an event's course against a past activity's course. A different
+     * courseId means the prior profile does not apply; an absent reference is
+     * reported as unknown rather than assumed equal. */
+    async diffCourseProfiles(eventCourseId, pastActivityId) {
+        const caveats = [];
+        let pastActivityCourseId = null;
+        if (pastActivityId) {
+            const activities = await this.repository.rows(`SELECT payload_json FROM source_entities
+         WHERE entity_type = 'activity' AND remote_id = $activityId LIMIT 1`, { activityId: pastActivityId });
+            if (activities.length > 0) {
+                pastActivityCourseId = extractCourseId(activities[0].payload_json);
+            }
+            else {
+                caveats.push(`No activity source entity found for pastActivityId ${pastActivityId}; could not resolve its course.`);
+            }
+        }
+        let sameCourse = null;
+        let differentCourse = null;
+        if (eventCourseId !== null && pastActivityCourseId !== null) {
+            sameCourse = eventCourseId === pastActivityCourseId;
+            differentCourse = !sameCourse;
+            if (differentCourse) {
+                caveats.push(`Event courseId ${eventCourseId} differs from past activity courseId ${pastActivityCourseId}; do not reuse the prior course profile.`);
+            }
+        }
+        else if (eventCourseId === null) {
+            caveats.push('Event courseId is unknown; a prior course profile cannot be validated against it.');
+        }
+        else {
+            caveats.push('Past activity courseId is unknown; a prior course profile cannot be confirmed or refuted.');
+        }
+        return { eventCourseId, pastActivityCourseId, sameCourse, differentCourse, caveats };
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/core/query/fitness.d.ts

@@ -26,6 +26,9 @@ export type LatestCyclingActivitiesRequest = FitnessDateRange & {
     includeMultisport?: boolean;
     limit?: number;
 };
+export type ReadinessBaselineRequest = FitnessDateRange & {
+    sport?: string;
+};
 /** Read-only, source-aware fitness projections built on normalized facts. */
 export declare class FitnessService {
     private readonly repository;
@@ -36,5 +39,6 @@ export declare class FitnessService {
     powerCoverageReport(request?: PowerCoverageReportRequest): Promise<Record<string, unknown>>;
     latestCyclingActivities(request?: LatestCyclingActivitiesRequest): Promise<Record<string, unknown>>;
     cyclingProgressReport(request?: FitnessDateRange): Promise<Record<string, unknown>>;
+    readinessBaseline(request?: ReadinessBaselineRequest): Promise<Record<string, unknown>>;
 }
 export {};

package/dist/core/query/fitness.js

@@ -293,5 +293,65 @@ export class FitnessService {
             ],
         };
     }
+    async readinessBaseline(request = {}) {
+        const sport = request.sport ?? 'running';
+        const isRunning = /run/i.test(sport);
+        const values = { sport };
+        const metricClauses = [
+            `metric_name IN ('running_lactate_threshold_pace_s_per_km','running_lactate_threshold_power_w','running_lactate_threshold_hr_bpm','running_lactate_threshold_power_w_kg','race_prediction_time5_k','race_prediction_time10_k','race_prediction_time_half_marathon','race_prediction_time_marathon','training_status_fitness_trend','endurance_score_overall_score')`,
+            `(lower(sport) = lower($sport) OR lower(sport) = 'generic')`,
+            ...addDateRange('observed_at', request, values),
+        ];
+        const observations = await this.repository.rows(`
+      SELECT observation_id, cast(observed_at AS VARCHAR) AS observed_at, value_number, value_text, unit, sport,
+        source_type, source_remote_id, activity_source_id, raw_object_hash, metric_name
+      FROM training_metric_observations
+      WHERE ${metricClauses.join(' AND ')}
+      ORDER BY observed_at DESC, observation_id DESC
+    `, values);
+        const [vo2max, powerCurve, powerCoverage] = await Promise.all([
+            this.vo2MaxHistory({ ...request, sport }),
+            this.powerCurveTrend({ ...request, sportFamily: isRunning ? 'running' : 'cycling' }),
+            this.powerCoverageReport({ ...request, sportFamily: isRunning ? 'running' : 'cycling' }),
+        ]);
+        const byMetric = new Map();
+        for (const row of observations) {
+            const arr = byMetric.get(row.metric_name) ?? [];
+            arr.push(row);
+            byMetric.set(row.metric_name, arr);
+        }
+        const latest = (name) => byMetric.get(name)?.[0] ?? null;
+        const series = (name) => byMetric.get(name) ?? [];
+        return {
+            data: {
+                sport,
+                lactateThreshold: {
+                    pace_s_per_km: latest('running_lactate_threshold_pace_s_per_km'),
+                    power_w: latest('running_lactate_threshold_power_w'),
+                    hr_bpm: latest('running_lactate_threshold_hr_bpm'),
+                    power_w_kg: latest('running_lactate_threshold_power_w_kg'),
+                    powerSeries: series('running_lactate_threshold_power_w'),
+                },
+                vo2max,
+                racePrediction: {
+                    time5_k: latest('race_prediction_time5_k'),
+                    time10_k: latest('race_prediction_time10_k'),
+                    timeHalfMarathon: latest('race_prediction_time_half_marathon'),
+                    timeMarathon: latest('race_prediction_time_marathon'),
+                },
+                fitnessTrend: latest('training_status_fitness_trend'),
+                enduranceScore: latest('endurance_score_overall_score'),
+                powerCurve,
+                powerCoverage,
+            },
+            provenance: { dataset: 'training_metric_observations', powerDataset: 'power_best_facts' },
+            query: request,
+            caveats: [
+                'Readiness baseline is descriptive, not a physiological performance model; it combines lactate threshold, VO₂max, race prediction, fitness trend, and FIT-derived power.',
+                'Running power uses Garmin FIT-derived power bests (power_best_facts), not sparse activity-summary average power; a NULL summary avg_power does not mean no power.',
+                'Course/elevation profile for a specific race is not included here; call resolve_event_course(eventId) before reusing any prior course profile.',
+            ],
+        };
+    }
 }
 //# sourceMappingURL=fitness.js.map

package/dist/core/query/repository.d.ts

@@ -1,4 +1,5 @@
 import type { CatencePaths } from '../../contracts/runtime.js';
+import { type SyncProgressSnapshot } from '../../contracts/progress.js';
 import type { QueryValues, ReadDataStore } from '../../contracts/storage.js';
 import { type DatasetDefinition } from './catalog.js';
 export declare class ReadOnlyRepository {
@@ -10,6 +11,7 @@ export declare class ReadOnlyRepository {
     datasetRelation(datasetName: string): Promise<string>;
     activitySampleRelation(): Promise<string>;
     status(): Promise<Record<string, unknown>>;
+    progress(): Promise<SyncProgressSnapshot>;
     coverage(): Promise<Record<string, unknown>>;
     activity(activityId: string): Promise<Record<string, unknown> | null>;
     summary(startDate: string, endDate: string): Promise<Record<string, unknown>>;

package/dist/core/query/repository.js

@@ -1,5 +1,7 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { SYNC_STAGES } from '../../contracts/progress.js';
+import { mergeProgress, readRunningProgress } from '../../elt/storage/progress-sidecar.js';
 import { sqlString } from './sql.js';
 import { DATASET_CATALOG, getDataset } from './catalog.js';
 export class ReadOnlyRepository {
@@ -137,6 +139,38 @@ export class ReadOnlyRepository {
             incrementalCursors: cursors,
         };
     }
+    async progress() {
+        // Same sequential-read discipline as status(): the shared native
+        // connection must not run these small reads concurrently.
+        const running = await this.rows(`
+      SELECT runs.run_id, runs.provider, coalesce(progress.stage, 'starting') AS stage,
+        progress.current_step,
+        coalesce(progress.completed_units, 0) AS completed_units,
+        progress.total_units,
+        coalesce(progress.percent, 0) AS percent,
+        coalesce(progress.elapsed_seconds, 0) AS elapsed_seconds,
+        progress.estimated_remaining_seconds,
+        cast(coalesce(progress.heartbeat_at, runs.started_at) AS VARCHAR) AS heartbeat_at
+      FROM sync_runs AS runs
+      LEFT JOIN sync_run_progress AS progress USING (run_id)
+      WHERE runs.status = 'running'
+      ORDER BY runs.started_at DESC
+    `);
+        const recent = await this.rows(`
+      SELECT run_id, provider, stage, current_step, completed_units, total_units, percent,
+        elapsed_seconds, estimated_remaining_seconds,
+        cast(heartbeat_at AS VARCHAR) AS heartbeat_at
+      FROM sync_run_progress
+      ORDER BY heartbeat_at DESC
+      LIMIT 10
+    `);
+        // Merge with sidecar heartbeat files so an active Garmin run stays visible
+        // even while the same process holds the single-writer database lock. The
+        // filtered reader guarantees a terminal or stale heartbeat can never read
+        // as an active run again, so a finished sync cannot block new ones.
+        const runningSidecars = await readRunningProgress(this.paths);
+        return mergeProgress(running.map(toSyncProgressState), recent.map(toSyncProgressState), runningSidecars);
+    }
     async coverage() {
         const rows = await this.rows(`
       SELECT 'activities' AS dataset, min(cast(started_at_utc AS DATE)) AS start_date, max(cast(started_at_utc AS DATE)) AS end_date, count(*)::INTEGER AS row_count FROM activities
@@ -166,6 +200,20 @@ export class ReadOnlyRepository {
         return Object.values(DATASET_CATALOG);
     }
 }
+function toSyncProgressState(row) {
+    return {
+        runId: row.run_id,
+        provider: row.provider,
+        stage: SYNC_STAGES.includes(row.stage) ? row.stage : 'starting',
+        currentStep: row.current_step,
+        completedUnits: Math.max(0, Number(row.completed_units) || 0),
+        totalUnits: row.total_units === null || row.total_units === undefined ? null : Math.max(0, Number(row.total_units) || 0),
+        percentComplete: Math.min(100, Math.max(0, Number(row.percent) || 0)),
+        elapsedSeconds: Math.max(0, Number(row.elapsed_seconds) || 0),
+        estimatedRemainingSeconds: row.estimated_remaining_seconds === null || row.estimated_remaining_seconds === undefined ? null : Math.max(0, Number(row.estimated_remaining_seconds) || 0),
+        heartbeatAt: row.heartbeat_at,
+    };
+}
 /** Converts DuckDB's Date/BigInt values into MCP-safe JSON values. */
 export function jsonSafe(value) {
     if (typeof value === 'bigint')

package/dist/core/query/swimming.js

@@ -86,7 +86,7 @@ export class SwimmingService {
                 availability: {
                     explicitLengthFacts: lengths.length > 0,
                     setFacts: sets.length > 0,
-                    perLengthPaceAvailable: lengths.some((length) => Number(length.duration_s) > 0 && Number(length.distance_m) > 0),
+                    perLengthPaceAvailable: lengths.some((length) => Number(length.duration_s) > 0),
                 },
             };
         }));
@@ -123,7 +123,7 @@ export class SwimmingService {
         FROM activity_quality_flags GROUP BY activity_source_id
       ), lengths AS (
         SELECT activity_source_id, count(*) AS length_fact_count,
-          count(*) FILTER (WHERE duration_s > 0 AND distance_m > 0) AS pace_length_fact_count
+          count(*) FILTER (WHERE duration_s > 0) AS pace_length_fact_count
         FROM swim_lengths GROUP BY activity_source_id
       ), sets AS (
         SELECT activity_source_id, count(*) AS set_fact_count FROM swim_sets GROUP BY activity_source_id

package/dist/core/runtime/configuration.d.ts

@@ -12,7 +12,7 @@ declare const rateLimitSchema: z.ZodObject<{
     requests: z.ZodNumber;
     windowSeconds: z.ZodNumber;
 }, z.core.$strict>;
-declare const catenceConfigSchema: z.ZodObject<{
+export declare const catenceConfigSchema: z.ZodObject<{
     mcp: z.ZodOptional<z.ZodObject<{
         rateLimits: z.ZodOptional<z.ZodObject<{
             server: z.ZodOptional<z.ZodNullable<z.ZodObject<{
@@ -50,6 +50,8 @@ declare const catenceConfigSchema: z.ZodObject<{
             models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 label: z.ZodOptional<z.ZodString>;
                 model: z.ZodString;
+                reasoningEffort: z.ZodOptional<z.ZodString>;
+                variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strict>>>;
             defaultModel: z.ZodOptional<z.ZodString>;
             defaultReasoningEffort: z.ZodOptional<z.ZodEnum<{

package/dist/core/runtime/configuration.js

@@ -32,9 +32,13 @@ export function requireIntervalsConfig(environment = process.env) {
 const rateLimitSchema = z.object({ requests: z.number().int().positive(), windowSeconds: z.number().int().positive() }).strict();
 const nullableRateLimitSchema = rateLimitSchema.nullable();
 const environmentVariableSchema = z.string().regex(/^[A-Z][A-Z0-9_]*$/, 'must be an uppercase environment-variable name');
+// Keep this aligned with the Console's Python validator, which accepts a
+// per-model reasoningEffort and free-form reasoning-effort variants.
 const consoleModelSchema = z.object({
     label: z.string().min(1).optional(),
     model: z.string().min(1),
+    reasoningEffort: z.string().min(1).optional(),
+    variants: z.record(z.string(), z.string()).optional(),
 }).strict();
 const consoleProfileSchema = z.object({
     label: z.string().min(1).optional(),
@@ -60,7 +64,7 @@ const consoleLimitsSchema = z.object({
     toolRounds: z.number().int().min(1).max(32).optional(),
     toolResultCharacters: z.number().int().min(1_000).max(250_000).optional(),
 }).strict();
-const catenceConfigSchema = z.object({
+export const catenceConfigSchema = z.object({
     mcp: z.object({
         rateLimits: z.object({
             server: nullableRateLimitSchema.optional(),

package/dist/core/runtime/opencode-go.d.ts

@@ -0,0 +1,58 @@
+export declare const OPENCODE_GO_DEFAULT_BASE_URL = "https://opencode.ai/zen/go/v1";
+export declare const OPENCODE_GO_API_KEY_ENV = "OPENCODE_GO_API_KEY";
+export declare const OPENCODE_GO_API_BASE_ENV = "OPENCODE_GO_API_BASE";
+export declare const OPENCODE_GO_MESSAGES_API_BASE_ENV = "OPENCODE_GO_MESSAGES_API_BASE";
+export type OpenCodeGoRoute = 'chat' | 'responses' | 'messages';
+/** Live model ids plus trusted routing metadata ("live discovery + trusted metadata"). */
+export declare function classifyOpenCodeGoModel(id: string): {
+    route: OpenCodeGoRoute;
+    guessed: boolean;
+};
+export type OpenCodeGoConsoleProfiles = {
+    profiles: Record<string, Record<string, unknown>>;
+    defaultProfile: string;
+    counts: {
+        chat: number;
+        responses: number;
+        messages: number;
+    };
+    guessedRoutes: string[];
+};
+/**
+ * Build the two ready-made Console profiles from live model ids.
+ *
+ * The public `GET /models` endpoint returns only ids, not which API each model
+ * needs, so routing comes from the trusted table intersected with the live
+ * list; prefix-guessed routes are reported so callers can warn.
+ */
+export declare function buildOpenCodeGoConsoleProfiles(modelIds: readonly string[], baseUrl?: string): OpenCodeGoConsoleProfiles;
+export declare function fetchOpenCodeGoModelIds(baseUrl?: string): Promise<string[]>;
+export type OpenCodeGoMergeResult = {
+    configPath: string;
+    mergedProfileIds: string[];
+    defaultProfile: string;
+    counts: {
+        chat: number;
+        responses: number;
+        messages: number;
+    };
+    guessedRoutes: string[];
+    /** Model ids removed from the managed profiles because they left the live catalog. */
+    prunedModelIds?: string[];
+};
+/**
+ * Fetch the live OpenCode Go catalog and merge the two Console profiles into
+ * `configPath`, preserving every other section plus existing console fields
+ * (`limits`, other profiles) and the existing `defaultProfile` unless
+ * `setDefault` is passed. Model routing (`model`) is refreshed from the live
+ * catalog, per-model customizations (custom label, `reasoningEffort`,
+ * `variants`) survive for models still in the catalog, and models that
+ * disappeared upstream are pruned so the Console never offers stale routes.
+ * The written file is re-validated with the same strict schema the runtime
+ * applies on load, then replaced atomically.
+ */
+export declare function mergeOpenCodeGoConsoleProfiles(options: {
+    configPath: string;
+    baseUrl?: string;
+    setDefault?: boolean;
+}): Promise<OpenCodeGoMergeResult>;

package/dist/core/runtime/opencode-go.js

@@ -0,0 +1,246 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { catenceConfigSchema } from './configuration.js';
+export const OPENCODE_GO_DEFAULT_BASE_URL = 'https://opencode.ai/zen/go/v1';
+export const OPENCODE_GO_API_KEY_ENV = 'OPENCODE_GO_API_KEY';
+export const OPENCODE_GO_API_BASE_ENV = 'OPENCODE_GO_API_BASE';
+export const OPENCODE_GO_MESSAGES_API_BASE_ENV = 'OPENCODE_GO_MESSAGES_API_BASE';
+// LiteLLM appends a fixed suffix to the profile base URL per provider, so the
+// three APIs need different prefixes and two base URLs:
+//   openai/<id>             -> {base}/chat/completions
+//   openai/responses/<id>   -> {base}/responses
+//   anthropic/<id>          -> {base minus /v1}/v1/messages
+const RESPONSES_MODELS = new Set(['grok-4.5', 'gpt-5.6-luna']);
+const MESSAGES_MODELS = new Set([
+    'minimax-m2.5',
+    'minimax-m2.7',
+    'minimax-m3',
+    'qwen3.5-plus',
+    'qwen3.6-plus',
+    'qwen3.7-plus',
+    'qwen3.7-max',
+    'qwen3.8-max',
+]);
+const BRAND_NAMES = new Map([
+    ['deepseek', 'DeepSeek'],
+    ['glm', 'GLM'],
+    ['gpt', 'GPT'],
+    ['grok', 'Grok'],
+    ['hy3', 'Hy3'],
+    ['kimi', 'Kimi'],
+    ['mimo', 'MiMo'],
+    ['minimax', 'MiniMax'],
+    ['qwen', 'Qwen'],
+]);
+const CHAT_PROFILE_ID = 'opencode-go';
+const MESSAGES_PROFILE_ID = 'opencode-go-messages';
+/** Live model ids plus trusted routing metadata ("live discovery + trusted metadata"). */
+export function classifyOpenCodeGoModel(id) {
+    if (RESPONSES_MODELS.has(id))
+        return { route: 'responses', guessed: false };
+    if (MESSAGES_MODELS.has(id))
+        return { route: 'messages', guessed: false };
+    if (/^(grok-|gpt-)/.test(id))
+        return { route: 'responses', guessed: true };
+    if (/^(minimax-|qwen)/.test(id))
+        return { route: 'messages', guessed: true };
+    return { route: 'chat', guessed: false };
+}
+function modelReference(id, route) {
+    if (route === 'responses')
+        return `openai/responses/${id}`;
+    if (route === 'messages')
+        return `anthropic/${id}`;
+    return `openai/${id}`;
+}
+function labelFor(id) {
+    return id
+        .split('-')
+        .map((segment) => BRAND_NAMES.get(segment) ?? segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join(' ');
+}
+/**
+ * Build the two ready-made Console profiles from live model ids.
+ *
+ * The public `GET /models` endpoint returns only ids, not which API each model
+ * needs, so routing comes from the trusted table intersected with the live
+ * list; prefix-guessed routes are reported so callers can warn.
+ */
+export function buildOpenCodeGoConsoleProfiles(modelIds, baseUrl = OPENCODE_GO_DEFAULT_BASE_URL) {
+    const groups = { chat: [], responses: [], messages: [] };
+    const guessedRoutes = [];
+    for (const id of modelIds) {
+        if (!id)
+            continue;
+        const { route, guessed } = classifyOpenCodeGoModel(id);
+        groups[route].push(id);
+        if (guessed)
+            guessedRoutes.push(`${id} -> ${route}`);
+    }
+    for (const route of Object.keys(groups))
+        groups[route].sort();
+    const chatModels = {};
+    for (const id of [...groups.chat, ...groups.responses]) {
+        chatModels[id] = { label: labelFor(id), model: modelReference(id, groups.chat.includes(id) ? 'chat' : 'responses') };
+    }
+    const messagesModels = {};
+    for (const id of groups.messages) {
+        messagesModels[id] = { label: labelFor(id), model: modelReference(id, 'messages') };
+    }
+    const chatDefault = groups.chat[0] ?? groups.responses[0];
+    const profiles = {
+        [CHAT_PROFILE_ID]: {
+            label: 'OpenCode Go',
+            ...(chatDefault ? { defaultModel: chatDefault } : {}),
+            models: chatModels,
+            apiKeyEnv: OPENCODE_GO_API_KEY_ENV,
+            apiBaseEnv: OPENCODE_GO_API_BASE_ENV,
+        },
+    };
+    if (groups.messages.length) {
+        profiles[MESSAGES_PROFILE_ID] = {
+            label: 'OpenCode Go (Anthropic)',
+            defaultModel: groups.messages[0],
+            models: messagesModels,
+            apiKeyEnv: OPENCODE_GO_API_KEY_ENV,
+            apiBaseEnv: OPENCODE_GO_MESSAGES_API_BASE_ENV,
+        };
+    }
+    return {
+        profiles,
+        defaultProfile: CHAT_PROFILE_ID,
+        counts: { chat: groups.chat.length, responses: groups.responses.length, messages: groups.messages.length },
+        guessedRoutes,
+    };
+}
+export async function fetchOpenCodeGoModelIds(baseUrl = OPENCODE_GO_DEFAULT_BASE_URL) {
+    const modelsUrl = `${baseUrl.replace(/\/$/, '')}/models`;
+    let response;
+    try {
+        response = await fetch(modelsUrl, { headers: { accept: 'application/json' } });
+    }
+    catch (error) {
+        throw new Error(`Could not reach ${modelsUrl}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok)
+        throw new Error(`GET ${modelsUrl} returned HTTP ${response.status}.`);
+    const payload = (await response.json());
+    const ids = (payload.data ?? []).map((entry) => entry.id).filter((id) => typeof id === 'string' && Boolean(id));
+    if (!ids.length)
+        throw new Error(`GET ${modelsUrl} returned no models.`);
+    return ids;
+}
+async function readConfigRoot(configPath) {
+    try {
+        const root = JSON.parse(await readFile(configPath, 'utf8'));
+        if (typeof root !== 'object' || root === null || Array.isArray(root)) {
+            throw new Error(`${configPath} must contain a JSON object.`);
+        }
+        return root;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+}
+/** Per-model fields a human may have customized after the initial discovery. */
+function preservedModelFields(previous) {
+    if (typeof previous !== 'object' || previous === null || Array.isArray(previous))
+        return {};
+    const raw = previous;
+    const preserved = {};
+    if (typeof raw.label === 'string' && raw.label.trim())
+        preserved.label = raw.label;
+    if (typeof raw.reasoningEffort === 'string')
+        preserved.reasoningEffort = raw.reasoningEffort;
+    if (raw.variants !== undefined)
+        preserved.variants = raw.variants;
+    return preserved;
+}
+/**
+ * Fetch the live OpenCode Go catalog and merge the two Console profiles into
+ * `configPath`, preserving every other section plus existing console fields
+ * (`limits`, other profiles) and the existing `defaultProfile` unless
+ * `setDefault` is passed. Model routing (`model`) is refreshed from the live
+ * catalog, per-model customizations (custom label, `reasoningEffort`,
+ * `variants`) survive for models still in the catalog, and models that
+ * disappeared upstream are pruned so the Console never offers stale routes.
+ * The written file is re-validated with the same strict schema the runtime
+ * applies on load, then replaced atomically.
+ */
+export async function mergeOpenCodeGoConsoleProfiles(options) {
+    const baseUrl = options.baseUrl ?? OPENCODE_GO_DEFAULT_BASE_URL;
+    const modelIds = await fetchOpenCodeGoModelIds(baseUrl);
+    const built = buildOpenCodeGoConsoleProfiles(modelIds, baseUrl);
+    const root = await readConfigRoot(options.configPath);
+    const existingConsole = typeof root.console === 'object' && root.console !== null && !Array.isArray(root.console)
+        ? root.console
+        : {};
+    const existingProfiles = typeof existingConsole.profiles === 'object' && existingConsole.profiles !== null && !Array.isArray(existingConsole.profiles)
+        ? existingConsole.profiles
+        : {};
+    const defaultProfile = typeof existingConsole.defaultProfile === 'string' && existingConsole.defaultProfile && !options.setDefault
+        ? existingConsole.defaultProfile
+        : built.defaultProfile;
+    // Merge per model, not per profile: discovery owns routing and the id list,
+    // but a human's label, reasoningEffort, and variants must survive every
+    // re-discovery. Models that vanished upstream are pruned so the managed
+    // profiles mirror the live catalog instead of going stale; a failed or
+    // empty catalog fetch never reaches this loop (fetch throws first).
+    const mergedProfiles = {};
+    const prunedModelIds = [];
+    for (const [profileId, builtProfile] of Object.entries(built.profiles)) {
+        const previousProfile = existingProfiles[profileId];
+        const rawModels = typeof previousProfile === 'object' && previousProfile !== null
+            ? previousProfile.models
+            : undefined;
+        const previousModels = typeof rawModels === 'object' && rawModels !== null && !Array.isArray(rawModels)
+            ? rawModels
+            : {};
+        const models = {};
+        for (const [modelId, entry] of Object.entries(builtProfile.models)) {
+            models[modelId] = {
+                ...preservedModelFields(previousModels[modelId]),
+                label: entry.label,
+                model: entry.model,
+            };
+        }
+        for (const modelId of Object.keys(previousModels)) {
+            if (!(modelId in models))
+                prunedModelIds.push(`${profileId}:${modelId}`);
+        }
+        const previousDefaultModel = typeof previousProfile === 'object' && previousProfile !== null
+            ? previousProfile.defaultModel
+            : undefined;
+        mergedProfiles[profileId] = {
+            ...builtProfile,
+            ...(typeof previousDefaultModel === 'string' && previousDefaultModel in models
+                ? { defaultModel: previousDefaultModel }
+                : {}),
+            models,
+        };
+    }
+    const updatedConsole = {
+        ...existingConsole,
+        defaultProfile,
+        profiles: { ...existingProfiles, ...mergedProfiles },
+    };
+    // Validate before writing anything: the runtime rejects invalid configs at
+    // load time, so a bad merge must never reach disk.
+    const candidate = { ...root, console: updatedConsole };
+    catenceConfigSchema.parse(candidate);
+    await mkdir(path.dirname(options.configPath), { recursive: true });
+    const temporaryPath = `${options.configPath}.tmp`;
+    await writeFile(temporaryPath, `${JSON.stringify(candidate, null, 2)}\n`, 'utf8');
+    await rename(temporaryPath, options.configPath);
+    return {
+        configPath: options.configPath,
+        mergedProfileIds: Object.keys(built.profiles),
+        defaultProfile,
+        counts: built.counts,
+        guessedRoutes: built.guessedRoutes,
+        prunedModelIds,
+    };
+}
+//# sourceMappingURL=opencode-go.js.map