catence 0.2.0-beta.9 → 0.2.1-beta.1

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/sql-guard.js

@@ -44,6 +44,26 @@ function normalizeRelation(name) {
     const relation = name.trim().replace(/\s+(?:as\s+)?(?:"[^"]+"|[A-Za-z_][A-Za-z0-9_]*)\s*$/i, '');
     return relation.replaceAll('"', '').split('.').at(-1).toLowerCase();
 }
+// Physical base tables that are reachable only through cataloged views
+// (e.g. the events/workouts/routes/… domain projections over domain_entities).
+// They must be accepted when DuckDB resolves a cataloged view down to its base
+// table after tableNames(), but must never be writable directly by name.
+const INDIRECT_BASE_TABLES = new Set(['domain_entities']);
+// dataset->named tool hints for the common dead-end relations, so a rejected
+// query tells the agent where to go instead of just that it was denied.
+const RELATION_HINTS = {
+    events: 'events is a domain projection; use aggregate_data on events or resolve_event_course(eventId) / search_context to read events and races.',
+    workouts: 'workouts is a domain projection; use aggregate_data on workouts or search_context to read workouts.',
+    workout_documents: 'workout_documents is a domain projection; use aggregate_data on workout_documents or search_context to read workout documents.',
+    training_plans: 'training_plans is a domain projection; use aggregate_data on training_plans or search_context to read training plans.',
+    routes: 'routes is a domain projection; use aggregate_data on routes or search_context to read routes.',
+    gear: 'gear is a domain projection; use aggregate_data on gear or search_context to read saved gear.',
+    devices: 'devices is a domain projection; use aggregate_data on devices or search_context to read devices.',
+    goals: 'goals is a domain projection; use aggregate_data on goals or search_context to read goals and challenges.',
+    achievements: 'achievements is a domain projection; use aggregate_data on achievements or search_context to read badges and personal records.',
+    messages: 'messages is a domain projection; use aggregate_data on messages or search_context to read provider messages.',
+    course_geometry: 'course_geometry is the per-point course track (lat/lon/altitude_m/distance_m); resolve a race course first with resolve_event_course, then query it for elevation/height profiles.',
+};
 export async function queryReadOnlyData(repository, request) {
     const sql = safeSql(request.sql);
     let relations;
@@ -53,16 +73,28 @@ export async function queryReadOnlyData(repository, request) {
     catch (error) {
         throw new QueryValidationError(`SQL could not be inspected: ${error instanceof Error ? error.message : String(error)}`);
     }
-    const allowed = new Set(Object.values(DATASET_CATALOG).filter((dataset) => !dataset.samplesOnly && dataset.relation).map((dataset) => dataset.relation.toLowerCase()));
+    // The catalog relation names form the strict allow-list for what a query may
+    // name directly (Check B below). Base tables reached only through cataloged
+    // views are additionally permitted after DuckDB resolves views for Check A,
+    // but they are never valid relation names in the SQL text.
+    const allowedNamed = new Set(Object.values(DATASET_CATALOG).filter((dataset) => !dataset.samplesOnly && dataset.relation).map((dataset) => dataset.relation.toLowerCase()));
+    const allowedForExpansion = new Set([...allowedNamed, ...INDIRECT_BASE_TABLES]);
+    const rejected = [];
     for (const relation of relations) {
-        if (!allowed.has(normalizeRelation(relation)))
-            throw new QueryValidationError(`Relation ${relation} is not in the read-only catalog.`);
+        const normalized = normalizeRelation(relation);
+        if (!allowedForExpansion.has(normalized))
+            rejected.push(relation);
+    }
+    if (rejected.length > 0) {
+        const name = normalizeRelation(rejected[0]);
+        throw new QueryValidationError(`Relation ${rejected[0]} is not in the read-only catalog.${RELATION_HINTS[name] ? ` ${RELATION_HINTS[name]}` : ''}`);
     }
     const ctes = new Set([...sql.matchAll(/(?:\bwith|,)\s*([A-Za-z_][A-Za-z0-9_]*)\s+as\s*\(/gi)].map((match) => match[1].toLowerCase()));
     for (const match of sql.matchAll(/\b(?:from|join)\s+([A-Za-z_][A-Za-z0-9_.]*)/gi)) {
         const relation = normalizeRelation(match[1]);
-        if (!allowed.has(relation) && !ctes.has(relation))
-            throw new QueryValidationError(`Relation ${match[1]} is not in the read-only catalog.`);
+        if (!allowedNamed.has(relation) && !ctes.has(relation)) {
+            throw new QueryValidationError(`Relation ${match[1]} is not in the read-only catalog.${RELATION_HINTS[relation] ? ` ${RELATION_HINTS[relation]}` : ''}`);
+        }
     }
     const values = request.values ?? {};
     if ('__catence_page_size' in values || '__catence_offset' in values)

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>;