@wattsonclub/wattson-cli 0.1.0 → 0.1.1

package/dist/bin.js

@@ -5,8 +5,8 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/cli.ts
-import { readFile as readFile2 } from "node:fs/promises";
+// src/tool-command.ts
+import { readFile } from "node:fs/promises";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -6169,13 +6169,13 @@ function createPlannerClient(options = {}) {
       try {
         return await fetchImpl(buildUrl(baseUrl, input.path, input.query), {
           method,
+          redirect: "error",
           headers,
           ...body === void 0 ? {} : { body }
         });
       } catch (error) {
         throw new PlannerClientError({
-          message: error instanceof Error ? error.message : "Planner request failed.",
-          cause: error
+          message: "Unable to reach the planner API. Check the connection and selected API URL."
         });
       }
     }
@@ -6193,18 +6193,33 @@ function createPlannerClient(options = {}) {
       const parsedError = PlannerApiErrorSchema.safeParse(payload);
       if (parsedError.success) {
         throw new PlannerClientError({
-          message: parsedError.data.error.message,
+          message: {
+            bad_request: "Invalid request. Check the command input schema.",
+            unauthorized: "Authentication required. Sign in again.",
+            forbidden: "This operation is not permitted for this account or access mode.",
+            not_found: "Requested resource was not found.",
+            conflict: "The resource changed or conflicts with this request. Fetch the latest version and retry.",
+            unprocessable: "The request could not be processed. Check its inputs and validation result.",
+            too_many_requests: "Too many requests. Try again later.",
+            service_unavailable: "The planner service is temporarily unavailable.",
+            internal: "The planner service encountered an error."
+          }[parsedError.data.error.code],
           statusCode: response.status,
           code: parsedError.data.error.code,
-          details: parsedError.data.error.details
+          // Never forward server diagnostic text or echoed sensitive input.
+          details: []
         });
       }
       throw new PlannerClientError({
-        message: typeof payload === "string" && payload.length > 0 ? payload : `Planner request failed with HTTP ${response.status}.`,
+        message: `Planner request failed with HTTP ${response.status}.`,
         statusCode: response.status
       });
     }
-    return input.outputSchema.parse(payload);
+    const parsedOutput = input.outputSchema.safeParse(payload);
+    if (!parsedOutput.success) {
+      throw new PlannerClientError({ message: "The planner API returned an unexpected response.", statusCode: response.status });
+    }
+    return parsedOutput.data;
   }
   return {
     baseUrl,
@@ -6658,6 +6673,16 @@ function createPlannerClient(options = {}) {
         outputSchema: ListMySavedWorkoutsOutputSchema
       });
     },
+    async createMyWorkoutShare(input) {
+      const parsed = CreateWorkoutShareInputSchema.parse(input);
+      return request({ method: "POST", path: "/me/workout-shares", body: parsed, outputSchema: CreateWorkoutShareOutputSchema });
+    },
+    async getMyWorkoutSharePreview(shareId) {
+      return request({ method: "GET", path: `/me/workout-shares/${encodeURIComponent(shareId)}`, outputSchema: ImportWorkoutShareOutputSchema.omit({ alreadyImported: true }) });
+    },
+    async importMyWorkoutShare(shareId) {
+      return request({ method: "POST", path: `/me/workout-shares/${encodeURIComponent(shareId)}/import`, outputSchema: ImportWorkoutShareOutputSchema });
+    },
     async uploadMyCompletedRide(input) {
       const { rideId, ...body } = UploadCompletedRideInputSchema.parse(input);
       return request({
@@ -6850,10 +6875,273 @@ function createPlannerClient(options = {}) {
   };
 }
 
+// ../planner-client/src/research.ts
+function scoreResearchDocument(document, query) {
+  const tokens = query.toLowerCase().split(/[^a-z0-9]+/i).map((token) => token.trim()).filter((token) => token.length > 0);
+  if (tokens.length === 0) {
+    return 1;
+  }
+  const haystack = [
+    document.title,
+    document.url,
+    document.text,
+    JSON.stringify(document.metadata ?? {})
+  ].join("\n").toLowerCase();
+  return tokens.reduce((score, token) => score + (haystack.includes(token) ? 1 : 0), 0);
+}
+async function buildResearchDocuments(client) {
+  const documents = [];
+  const [profileResult, sessionsResult, workoutsResult] = await Promise.allSettled([
+    client.getMyProfile(),
+    client.getMyRecentSessions({ limit: 10 }),
+    client.listMySavedWorkouts()
+  ]);
+  if (profileResult.status === "fulfilled") {
+    documents.push({
+      id: `profile:${profileResult.value.profile.athleteId}`,
+      title: `${profileResult.value.profile.athleteId} athlete profile`,
+      url: `${client.baseUrl}/me/profile`,
+      text: JSON.stringify(profileResult.value.profile, null, 2),
+      metadata: {
+        kind: "athlete_profile",
+        athleteId: profileResult.value.profile.athleteId
+      }
+    });
+  }
+  if (sessionsResult.status === "fulfilled") {
+    for (const session of sessionsResult.value.sessions) {
+      documents.push({
+        id: `session:${session.id}`,
+        title: `Workout session ${session.id}`,
+        url: `${client.baseUrl}/me/runtime/sessions/${encodeURIComponent(session.id)}/summary`,
+        text: JSON.stringify(session, null, 2),
+        metadata: {
+          kind: "workout_session",
+          athleteId: session.athleteId,
+          sessionId: session.id,
+          workoutId: session.workoutId,
+          status: session.status
+        }
+      });
+    }
+  }
+  if (workoutsResult.status === "fulfilled") {
+    for (const record of workoutsResult.value.workouts) {
+      documents.push({
+        id: `workout:${record.workout.id}:v${record.workout.version}`,
+        title: record.workout.title ?? record.runtimePlan.title,
+        url: `${client.baseUrl}/me/workouts/${encodeURIComponent(record.workout.id)}?workoutVersion=${record.workout.version}`,
+        text: JSON.stringify(record, null, 2),
+        metadata: {
+          kind: "saved_workout",
+          athleteId: record.workout.athleteId,
+          workoutId: record.workout.id,
+          workoutVersion: record.workout.version
+        }
+      });
+    }
+  }
+  return documents;
+}
+async function searchPlannerResearch(client, query) {
+  const documents = await buildResearchDocuments(client);
+  return { results: documents.map((document) => ({ document, score: scoreResearchDocument(document, query) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.document.title.localeCompare(b.document.title)).slice(0, 8).map(({ document, score }) => ({ id: document.id, title: document.title, url: document.url, score })) };
+}
+async function fetchPlannerResearch(client, id) {
+  const document = (await buildResearchDocuments(client)).find((candidate) => candidate.id === id);
+  if (!document) throw new Error(`Unknown research document ${id}.`);
+  return document;
+}
+
+// src/parity.ts
+var shareSchema = external_exports.object({ shareId: external_exports.string().uuid() });
+var emptySchema = external_exports.object({});
+var toolRoutes = [
+  { tool: "list_saved_workouts", command: "workout list", internal: "listSavedWorkouts", public: "listMySavedWorkouts", schema: ListSavedWorkoutsInputSchema, publicSchema: ListMySavedWorkoutsInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "health", command: "health", internal: "health", public: "health", schema: emptySchema, publicSchema: emptySchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "get_athlete_profile", command: "athlete profile", internal: "getAthleteProfile", public: "getMyProfile", schema: GetAthleteProfileInputSchema, publicSchema: emptySchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "get_readiness_snapshot", command: "athlete readiness latest", internal: "getReadinessSnapshot", public: "getMyReadinessSnapshot", schema: GetReadinessSnapshotInputSchema, publicSchema: GetMyReadinessSnapshotInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "get_recent_sessions", command: "athlete sessions", internal: "getRecentSessions", public: "getMyRecentSessions", schema: GetRecentSessionsInputSchema, publicSchema: GetMyRecentSessionsInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "get_saved_workout", command: "workout get", internal: "getSavedWorkout", public: "getMySavedWorkout", schema: GetSavedWorkoutInputSchema, publicSchema: GetSavedWorkoutInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "get_workout_runtime_plan", command: "workout runtime-plan", internal: "getWorkoutRuntimePlan", public: "getMyWorkoutRuntimePlan", schema: GetWorkoutRuntimePlanInputSchema, publicSchema: GetWorkoutRuntimePlanInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "list_saved_workout_revisions", command: "workout revisions", internal: "listSavedWorkoutRevisions", public: "listMySavedWorkoutRevisions", schema: ListSavedWorkoutRevisionsInputSchema, publicSchema: ListSavedWorkoutRevisionsInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "summarize_session", command: "session summary", internal: "summarizeSession", public: "summarizeMySession", schema: SummarizeSessionInputSchema, publicSchema: SummarizeSessionInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "get_session_telemetry", command: "session telemetry", internal: "getSessionTelemetry", public: "getMySessionTelemetry", schema: GetSessionTelemetryInputSchema, publicSchema: GetSessionTelemetryInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "get_session_artifacts", command: "session artifacts", internal: "getSessionArtifacts", public: "getMySessionArtifacts", schema: GetSessionArtifactsInputSchema, publicSchema: GetSessionArtifactsInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "get_session_fit_export", command: "session fit", internal: "getSessionFitExport", public: "getMySessionFitExport", schema: GetSessionFitExportInputSchema, publicSchema: GetSessionFitExportInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "lookup_climb", command: "course lookup", internal: "lookupClimb", public: "lookupMyClimb", schema: LookupClimbInputSchema, publicSchema: LookupMyClimbInputSchema, extended: true, signedInOnly: false, limited: false, positional: "query" },
+  { tool: "find_my_strava_segments", command: "strava find-segments", internal: "findMyStravaSegments", public: "findMyStravaSegments", schema: FindStravaSegmentsInputSchema, publicSchema: FindStravaSegmentsInputSchema, extended: true, signedInOnly: true, limited: false, positional: "query" },
+  { tool: "import_strava_segment", command: "course import-strava-segment", internal: "importMyStravaSegment", public: "importMyStravaSegment", schema: ImportStravaSegmentInputSchema, publicSchema: ImportStravaSegmentInputSchema, extended: true, signedInOnly: true, limited: false, positional: "segment" },
+  { tool: "import_gpx_course", command: "course import-gpx", internal: "importGpxCourse", public: "importMyGpxCourse", schema: ImportGpxCourseInputSchema, publicSchema: ImportMyGpxCourseInputSchema, extended: true, signedInOnly: false, limited: false },
+  { tool: "generate_terrain_course", command: "course generate-terrain", internal: "generateTerrainCourse", public: "generateMyTerrainCourse", schema: GenerateTerrainCourseInputSchema, publicSchema: GenerateMyTerrainCourseInputSchema, extended: true, signedInOnly: false, limited: false },
+  { tool: "import_strava_activity_course", command: "course import-strava-activity", internal: "importMyStravaActivityCourse", public: "importMyStravaActivityCourse", schema: ImportStravaActivityCourseInputSchema, publicSchema: ImportStravaActivityCourseInputSchema, extended: true, signedInOnly: true, limited: true, positional: "activity" },
+  { tool: "build_road_course", command: "course build-road", internal: "buildRoadCourse", public: "buildMyRoadCourse", schema: BuildRoadCourseInputSchema, publicSchema: BuildMyRoadCourseInputSchema, extended: true, signedInOnly: false, limited: false },
+  { tool: "import_climb_page", command: "course import-climb-page", internal: "importClimbPage", public: "importMyClimbPage", schema: ImportClimbPageInputSchema, publicSchema: ImportMyClimbPageInputSchema, extended: true, signedInOnly: false, limited: false, positional: "url" },
+  { tool: "get_my_climb_history", command: "course history", internal: "getClimbHistory", public: "getMyClimbHistory", schema: GetClimbHistoryInputSchema, publicSchema: GetMyClimbHistoryInputSchema, extended: true, signedInOnly: false, limited: false },
+  { tool: "explore_strava_segments", command: "strava explore", internal: "exploreMyStravaSegments", public: "exploreMyStravaSegments", schema: ExploreStravaSegmentsInputSchema, publicSchema: ExploreStravaSegmentsInputSchema, extended: true, signedInOnly: true, limited: true },
+  { tool: "get_my_strava_segment_efforts", command: "strava segment-efforts", internal: "getMyStravaSegmentEfforts", public: "getMyStravaSegmentEfforts", schema: ListStravaSegmentEffortsInputSchema, publicSchema: ListStravaSegmentEffortsInputSchema, extended: true, signedInOnly: true, limited: true, positional: "segment" },
+  { tool: "list_my_strava_starred_segments", command: "strava starred-segments", internal: "listMyStravaStarredSegments", public: "listMyStravaStarredSegments", schema: ListStravaStarredSegmentsInputSchema, publicSchema: ListStravaStarredSegmentsInputSchema, extended: true, signedInOnly: true, limited: true },
+  { tool: "list_my_favourite_strava_climbs", command: "strava favourite-climbs", internal: "listMyFavouriteStravaClimbs", public: "listMyFavouriteStravaClimbs", schema: ListFavouriteStravaClimbsInputSchema, publicSchema: ListFavouriteStravaClimbsInputSchema, extended: true, signedInOnly: true, limited: true },
+  { tool: "recommend_first_workout", command: "recommend first", internal: "recommendMyOnboardingWorkout", public: "recommendMyOnboardingWorkout", schema: RecommendOnboardingWorkoutInputSchema, publicSchema: RecommendOnboardingWorkoutInputSchema, extended: true, signedInOnly: true, limited: false },
+  { tool: "list_my_strava_routes", command: "strava routes", internal: "listMyStravaRoutes", public: "listMyStravaRoutes", schema: ListStravaRoutesInputSchema, publicSchema: ListStravaRoutesInputSchema, extended: true, signedInOnly: true, limited: true },
+  { tool: "import_strava_route", command: "course import-strava-route", internal: "importMyStravaRoute", public: "importMyStravaRoute", schema: ImportStravaRouteInputSchema, publicSchema: ImportStravaRouteInputSchema, extended: true, signedInOnly: true, limited: true, positional: "route" },
+  { tool: "draft_workout", command: "workout draft", internal: "draftWorkout", public: "draftMyWorkout", schema: DraftWorkoutInputSchema, publicSchema: DraftMyWorkoutInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "revise_workout", command: "workout revise", internal: "reviseWorkout", public: "reviseMyWorkout", schema: ReviseWorkoutInputSchema, publicSchema: ReviseWorkoutInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "validate_workout", command: "workout validate", internal: "validateWorkout", public: "validateWorkout", schema: ValidateWorkoutInputSchema, publicSchema: ValidateWorkoutInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "save_workout", command: "workout save", internal: "saveWorkout", public: "saveMyWorkout", schema: SaveWorkoutInputSchema, publicSchema: SaveWorkoutInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "schedule_saved_workout", command: "workout schedule", internal: "scheduleSavedWorkout", public: "scheduleMySavedWorkout", schema: ScheduleSavedWorkoutInputSchema, publicSchema: ScheduleSavedWorkoutInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "retire_saved_workout", command: "workout retire", internal: "retireSavedWorkout", public: "retireMySavedWorkout", schema: RetireSavedWorkoutInputSchema, publicSchema: RetireSavedWorkoutInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "trigger_session_strava_sync", command: "session strava-sync", internal: "triggerSessionStravaSync", public: "triggerMySessionStravaSync", schema: TriggerSessionStravaSyncInputSchema, publicSchema: TriggerSessionStravaSyncInputSchema, extended: false, signedInOnly: false, limited: false },
+  { tool: "create_workout_share", command: "share create", internal: "createMyWorkoutShare", public: "createMyWorkoutShare", schema: CreateWorkoutShareInputSchema, publicSchema: CreateWorkoutShareInputSchema, extended: true, signedInOnly: true, limited: false, positional: "workoutId" },
+  { tool: "preview_workout_share", command: "share preview", internal: "getMyWorkoutSharePreview", public: "getMyWorkoutSharePreview", schema: shareSchema, publicSchema: shareSchema, extended: true, signedInOnly: true, limited: false, positional: "shareId", scalar: "shareId" },
+  { tool: "import_workout_share", command: "share import", internal: "importMyWorkoutShare", public: "importMyWorkoutShare", schema: shareSchema, publicSchema: shareSchema, extended: true, signedInOnly: true, limited: false, positional: "shareId", scalar: "shareId" }
+];
+
+// src/tool-command.ts
+var researchRoutes = [
+  { tool: "search", command: "research search", schema: external_exports.object({ query: external_exports.string().min(1) }) },
+  { tool: "fetch", command: "research fetch", schema: external_exports.object({ id: external_exports.string().min(1) }) }
+];
+function unwrap(schema) {
+  if (schema instanceof external_exports.ZodEffects) return unwrap(schema.innerType());
+  if (schema instanceof external_exports.ZodOptional || schema instanceof external_exports.ZodNullable) return unwrap(schema.unwrap());
+  if (schema instanceof external_exports.ZodDefault) return unwrap(schema.removeDefault());
+  return schema;
+}
+var kebab = (s) => s.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+function describeSchema(schema) {
+  const meta = schema.description ? { description: schema.description } : {};
+  if (schema instanceof external_exports.ZodEffects) return { ...describeSchema(schema.innerType()), ...meta };
+  if (schema instanceof external_exports.ZodOptional) return { ...describeSchema(schema.unwrap()), ...meta };
+  if (schema instanceof external_exports.ZodNullable) return { ...meta, anyOf: [describeSchema(schema.unwrap()), { type: "null" }] };
+  if (schema instanceof external_exports.ZodDefault) return { ...describeSchema(schema.removeDefault()), ...meta, default: schema._def.defaultValue() };
+  if (schema instanceof external_exports.ZodObject) return { ...meta, type: "object", properties: Object.fromEntries(Object.entries(schema.shape).map(([key, value]) => [key, describeSchema(value)])), required: Object.entries(schema.shape).filter(([, value]) => !value.isOptional()).map(([key]) => key), additionalProperties: schema._def.unknownKeys === "passthrough" };
+  if (schema instanceof external_exports.ZodArray) return { ...meta, type: "array", items: describeSchema(schema.element), ...schema._def.minLength ? { minItems: schema._def.minLength.value } : {}, ...schema._def.maxLength ? { maxItems: schema._def.maxLength.value } : {}, ...schema._def.exactLength ? { minItems: schema._def.exactLength.value, maxItems: schema._def.exactLength.value } : {} };
+  if (schema instanceof external_exports.ZodEnum) return { ...meta, type: "string", enum: schema.options };
+  if (schema instanceof external_exports.ZodUnion || schema instanceof external_exports.ZodDiscriminatedUnion) return { ...meta, anyOf: schema.options.map(describeSchema) };
+  if (schema instanceof external_exports.ZodLiteral) return { ...meta, const: schema.value };
+  if (schema instanceof external_exports.ZodRecord) return { ...meta, type: "object", additionalProperties: describeSchema(schema.valueSchema) };
+  if (schema instanceof external_exports.ZodNull) return { ...meta, type: "null" };
+  if (schema instanceof external_exports.ZodBoolean) return { ...meta, type: "boolean" };
+  if (schema instanceof external_exports.ZodUnknown || schema instanceof external_exports.ZodAny) return meta;
+  if (schema instanceof external_exports.ZodLazy) return describeSchema(schema.schema);
+  const result = { ...meta, type: schema instanceof external_exports.ZodNumber ? "number" : "string" };
+  for (const check of schema._def.checks ?? []) {
+    if (check.kind === "int") result.type = "integer";
+    if (check.kind === "min") result[schema instanceof external_exports.ZodString ? "minLength" : check.inclusive ? "minimum" : "exclusiveMinimum"] = check.value;
+    if (check.kind === "max") result[schema instanceof external_exports.ZodString ? "maxLength" : check.inclusive ? "maximum" : "exclusiveMaximum"] = check.value;
+    if (check.kind === "length") {
+      result.minLength = check.value;
+      result.maxLength = check.value;
+    }
+    if (check.kind === "multipleOf") result.multipleOf = check.value;
+    if (check.kind === "regex") result.pattern = check.regex.source;
+    if (["uuid", "email", "url", "datetime"].includes(check.kind)) result.format = { url: "uri", datetime: "date-time" }[check.kind] ?? check.kind;
+  }
+  return result;
+}
+function decode(raw, schema) {
+  const inner = unwrap(schema);
+  if (raw === "null" && schema.isNullable()) return null;
+  if (inner instanceof external_exports.ZodNumber) {
+    if (raw.trim() === "" || !Number.isFinite(Number(raw))) throw new Error(`Invalid number: ${raw}`);
+    return Number(raw);
+  }
+  if (inner instanceof external_exports.ZodBoolean) {
+    if (!["true", "false"].includes(raw)) throw new Error("Boolean values must be true or false.");
+    return raw === "true";
+  }
+  if (inner instanceof external_exports.ZodObject || inner instanceof external_exports.ZodArray || inner instanceof external_exports.ZodUnion) return JSON.parse(raw);
+  return raw;
+}
+function field(schema, name) {
+  const inner = unwrap(schema);
+  if (!(inner instanceof external_exports.ZodObject)) throw new Error(`Not an object: ${name}`);
+  const key = Object.keys(inner.shape).find((key2) => kebab(key2) === name || key2 === name);
+  if (!key) throw new Error(`Unknown option: --${name}`);
+  return [key, inner.shape[key]];
+}
+async function parseToolArgs(args, schema, positional) {
+  let input = {};
+  const jsonIndex = args.indexOf("--input-json"), fileIndex = args.indexOf("--input-file");
+  if (jsonIndex >= 0 && fileIndex >= 0) throw new Error("Use only one of --input-json or --input-file.");
+  const index = Math.max(jsonIndex, fileIndex);
+  if (index >= 0) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) throw new Error("Missing input value.");
+    input = JSON.parse(fileIndex >= 0 ? await readFile(value, "utf8") : value);
+    args.splice(index, 2);
+    if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("Input must be a JSON object.");
+    if (args.length) throw new Error("Do not combine JSON input with other arguments.");
+    return input;
+  }
+  if (positional && args[0] && !args[0].startsWith("--")) input[positional] = args.shift();
+  while (args.length) {
+    const option = args.shift();
+    if (!option.startsWith("--")) throw new Error(`Unexpected argument: ${option}`);
+    const raw = args.shift();
+    if (raw === void 0 || raw.startsWith("--")) throw new Error(`Missing value for ${option}.`);
+    if (option === "--gpx-file") {
+      field(schema, "gpx");
+      if ("gpx" in input) throw new Error("Duplicate GPX input.");
+      input.gpx = await readFile(raw, "utf8");
+      continue;
+    }
+    let current = input, currentSchema = schema;
+    const parts = option.slice(2).split(".");
+    for (const [i, part] of parts.entries()) {
+      const [key, valueSchema] = field(currentSchema, part);
+      if (i < parts.length - 1) {
+        current[key] ??= {};
+        current = current[key];
+        currentSchema = valueSchema;
+      } else {
+        const inner = unwrap(valueSchema);
+        if (inner instanceof external_exports.ZodArray && !raw.startsWith("[")) {
+          current[key] = [...current[key] ?? [], decode(raw, inner.element)];
+        } else {
+          if (key in current) throw new Error(`Duplicate option: ${option}`);
+          current[key] = decode(raw, valueSchema);
+        }
+      }
+    }
+  }
+  return input;
+}
+async function runToolCommand(args, client, signedIn, limited) {
+  const generic = args[0] === "tool";
+  if (generic && args[1] === "list" && args.length !== 2) throw new Error("tool list does not accept arguments.");
+  if (generic && args[1] === "schema" && args.length !== 3) throw new Error("Use tool schema <MCP-name>.");
+  if (generic && args[1] === "list") return { result: [...toolRoutes.filter((r) => !limited || !r.limited).map(({ tool, command }) => ({ tool, command })), ...researchRoutes.map(({ tool, command }) => ({ tool, command }))] };
+  const schemaOnly = generic && args[1] === "schema";
+  const toolName = generic ? args[schemaOnly ? 2 : 1] : void 0;
+  const route = toolRoutes.find((r) => generic ? r.tool === toolName : r.extended && r.command.split(" ").every((s, i) => args[i] === s));
+  const research = researchRoutes.find((r) => generic ? r.tool === toolName : r.command.split(" ").every((s, i) => args[i] === s));
+  if (!route && !research) {
+    if (generic) throw new Error(`Unknown tool: ${toolName}`);
+    return void 0;
+  }
+  if (route?.limited && limited) throw new Error("This command is unavailable in Strava limited-access mode.");
+  const schema = research?.schema ?? (signedIn ? route.publicSchema : route.schema);
+  if (schemaOnly) return { result: { tool: toolName, command: (route ?? research).command, inputSchema: describeSchema(schema), note: "Contract refinements are validated on invocation. Flags use kebab-case; nested fields use dots; arrays accept JSON or repeated values." } };
+  if ((research || route?.signedInOnly) && !signedIn) throw new Error("Sign in with `wattson auth login` to use this command.");
+  args.splice(0, generic ? 2 : (route ?? research).command.split(" ").length);
+  const input = await parseToolArgs(args, schema, generic ? void 0 : research ? research.tool === "search" ? "query" : "id" : route.positional);
+  if (signedIn && "athleteId" in input && !unwrap(schema).shape.athleteId) throw new Error("Authenticated commands target the signed-in athlete; athleteId is not accepted.");
+  const parsed = schema.parse(input);
+  if (research) return { result: research.tool === "search" ? await searchPlannerResearch(client, parsed.query) : await fetchPlannerResearch(client, parsed.id) };
+  const selected = route;
+  const method = client[signedIn ? selected.public : selected.internal];
+  return { result: await method(selected.scalar ? parsed[selected.scalar] : parsed) };
+}
+
+// src/cli.ts
+import { readFile as readFile3 } from "node:fs/promises";
+
 // src/auth.ts
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile as readFile2, rename, rm, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import os from "node:os";
 import path from "node:path";
@@ -6967,7 +7255,7 @@ function parseJsonSafely2(raw) {
 }
 async function readStoredAuthState(authFilePath) {
   try {
-    const raw = await readFile(authFilePath, "utf8");
+    const raw = await readFile2(authFilePath, "utf8");
     const trimmed = raw.trim();
     if (trimmed.length === 0) {
       return void 0;
@@ -6977,7 +7265,7 @@ async function readStoredAuthState(authFilePath) {
     if (error.code === "ENOENT") {
       return void 0;
     }
-    throw error;
+    throw new Error("Unable to read saved login. Repair or remove the credential file, then sign in again.");
   }
 }
 async function writeStoredAuthState(authFilePath, state) {
@@ -6995,6 +7283,7 @@ async function writeStoredAuthState(authFilePath, state) {
 async function postTokenRequest(baseUrl, payload, fetchImpl) {
   const response = await fetchImpl(`${normalizeBaseUrl2(baseUrl)}/token`, {
     method: "POST",
+    redirect: "error",
     headers: {
       "content-type": "application/x-www-form-urlencoded"
     },
@@ -7006,7 +7295,7 @@ async function postTokenRequest(baseUrl, payload, fetchImpl) {
     throw new Error(`OAuth token endpoint returned an unexpected response (HTTP ${response.status}).`);
   }
   if (!response.ok || parsed.data.error) {
-    throw new Error(parsed.data.error_description ?? parsed.data.error ?? `OAuth token request failed with HTTP ${response.status}.`);
+    throw new Error(`OAuth token request failed with HTTP ${response.status}.`);
   }
   return parsed.data;
 }
@@ -7264,6 +7553,7 @@ async function loginWithDeviceFlow(options) {
     if (remaining <= 0) throw new Error("Device login timed out. Run login again.");
     return await fetchImpl(url, {
       ...init,
+      redirect: "error",
       signal: AbortSignal.timeout(Math.max(1, Math.ceil(Math.min(3e4, remaining))))
     });
   };
@@ -7358,34 +7648,41 @@ function usage() {
     "  auth status",
     "  auth logout",
     "",
-    "Inspection/runtime commands:",
+    "Inspection commands:",
     "  health",
     "  athlete profile [athleteId]",
     "  athlete readiness latest [athleteId] [--as-of <isoDateTime>]",
     "  athlete sessions [athleteId] [--from <date>] [--to <date>] [--limit <n>]",
-    "  plan current [athleteId]",
-    "  runtime-plan today [athleteId] [--date <date>]",
+    "  workout list [athleteId] [--limit <n>]",
     "  workout get <workoutId> [--version <n>]",
     "  workout revisions <workoutId>",
     "  workout runtime-plan <workoutId> --version <n>",
-    "  session load-workout [--athlete-id <athleteId>] --workout-id <id> --version <n>",
-    "  session complete <sessionId> [--status <status>] [--elapsed-sec <n>] [--completion-kind <kind>] [--started-at <iso>] [--ended-at <iso>] [--execution-mode <mode>] [--avg-power <n>] [--avg-hr-bpm <n>] [--max-hr-bpm <n>] [--compliance-pct <n>] [--completed-duration-sec <n>] [--completed-tss <n>] [--note <text> ...]",
-    "  session complete <sessionId> --input-json <json> | --input-file <path>",
     "  session summary <sessionId>",
     "  session telemetry <sessionId>",
     "  session artifacts <sessionId>",
     "  session fit <sessionId>",
     "  session strava-sync <sessionId>",
+    "  strava routes [--limit <n>]",
+    "  strava starred-segments [--limit <n>]",
+    "  course import-strava-route --input-json <json> | --input-file <path>",
+    "  course import-strava-segment --input-json <json> | --input-file <path>",
+    "",
+    "Extended MCP commands (all accept --input-json or --input-file):",
+    ...toolRoutes.filter((route) => route.extended).map((route) => `  ${route.command}${route.positional ? ` <${route.positional}>` : ""}`),
+    "  research search <query> | research fetch <documentId>",
+    "  tool list | tool schema <MCP-name> | tool <MCP-name> [--input-json <json>]",
+    "  Use tool schema for fields; flags use --kebab-case, nested --field.child, repeated arrays.",
     "",
-    "Authoring/adaptation commands:",
+    "Authoring/library commands:",
     "  recommend daily [athleteId] --available-time-min <n> [--date <date>] [--prefer-objective <objective>] [--hard-constraint <text> ...]",
     "  workout draft [athleteId] --objective <objective> --duration-min <n> [--execution-mode <mode> ...] [--max-pct-ftp <n>] [--style-hint <text> ...] [--readiness-snapshot-id <id>]",
     "  workout draft --input-json <json> | --input-file <path>",
     "  workout revise --input-json <json> | --input-file <path>",
     "  workout validate --input-json <json> | --input-file <path>",
     "  workout save --input-json <json> | --input-file <path>",
-    "  plan schedule [athleteId] --workout-id <id> --version <n> --date <date>",
-    "  session adapt <sessionId> --op <op> --reason <text> [--payload-json <json> | --payload-file <path>]"
+    "  workout schedule <workoutId> --date <YYYY-MM-DD>",
+    "  workout unschedule <workoutId>",
+    "  workout retire <workoutId>"
   ].join("\n");
 }
 function shiftRequired(args, label) {
@@ -7463,8 +7760,8 @@ function parseIntegerOption(raw, label) {
   if (raw === void 0) {
     return void 0;
   }
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed)) {
+  const parsed = Number(raw);
+  if (raw.trim() === "" || !Number.isInteger(parsed)) {
     throw new Error(`Invalid integer for ${label}: ${raw}.`);
   }
   return parsed;
@@ -7496,7 +7793,7 @@ async function readJsonInput(args, jsonFlag = "--input-json", fileFlag = "--inpu
     return parseJsonValue(inlineJson, jsonFlag);
   }
   if (filePath !== void 0) {
-    const raw = await readFile2(filePath, "utf8");
+    const raw = await readFile3(filePath, "utf8");
     return parseJsonValue(raw, fileFlag);
   }
   return void 0;
@@ -7671,24 +7968,6 @@ function summarizeWorkoutRuntimePlan(result) {
     `validation: ${result.validation.status}`
   ].join("\n");
 }
-function summarizeQueuedSession(result) {
-  return [
-    "session queued",
-    `sessionId: ${result.sessionId}`,
-    `status: ${result.status}`,
-    ...result.runtimePlanId ? [`runtimePlanId: ${result.runtimePlanId}`] : []
-  ].join("\n");
-}
-function summarizeCompletedSession(result) {
-  return [
-    "session completed",
-    `sessionId: ${result.session.id}`,
-    `status: ${result.session.status}`,
-    ...result.session.completionKind ? [`completionKind: ${result.session.completionKind}`] : [],
-    ...result.session.actualMetrics?.completedDurationSec === void 0 ? [] : [`completedDurationSec: ${result.session.actualMetrics.completedDurationSec}`],
-    ...result.session.actualMetrics?.compliancePct === void 0 ? [] : [`compliancePct: ${result.session.actualMetrics.compliancePct}`]
-  ].join("\n");
-}
 function summarizeStravaSync(result) {
   const strava = result.session.externalSync?.strava;
   return [
@@ -7710,15 +7989,6 @@ function summarizeRecommendation(result) {
     ...alternatives.length === 0 ? [] : ["alternatives:", ...alternatives.map((alt) => `- ${alt.objective} (${alt.durationMin} min)`)]
   ].join("\n");
 }
-function summarizeAdaptedSession(result) {
-  const adaptations = result.session.adaptations ?? [];
-  return [
-    "session adapted",
-    `sessionId: ${result.session.id}`,
-    `status: ${result.session.status}`,
-    `adaptations: ${adaptations.length}`
-  ].join("\n");
-}
 function summarizeAuthStatus(state) {
   return [
     "auth status",
@@ -7736,6 +8006,14 @@ function formatDefaultResult(commandKey, result) {
       return summarizeRecentSessions(result);
     case "recommend_daily":
       return summarizeRecommendation(result);
+    case "workout_list": {
+      const workouts = result.workouts;
+      return [
+        "saved workouts",
+        `count: ${workouts.length}`,
+        ...workouts.map(({ workout }) => `- ${workout.id} | v${workout.version} | ${workout.title} | ${workout.status} | ${workout.scheduledDate ?? "unscheduled"}`)
+      ].join("\n");
+    }
     case "workout_get":
       return summarizeSavedWorkout(result);
     case "workout_draft":
@@ -7748,10 +8026,6 @@ function formatDefaultResult(commandKey, result) {
       return summarizeWorkoutRevisions(result);
     case "workout_runtime_plan":
       return summarizeWorkoutRuntimePlan(result);
-    case "session_load_workout":
-      return summarizeQueuedSession(result);
-    case "session_complete":
-      return summarizeCompletedSession(result);
     case "session_summary":
       return summarizeSessionSummary(result);
     case "session_telemetry":
@@ -7762,8 +8036,6 @@ function formatDefaultResult(commandKey, result) {
       return summarizeFit(result);
     case "session_strava_sync":
       return summarizeStravaSync(result);
-    case "session_adapt":
-      return summarizeAdaptedSession(result);
     default:
       return JSON.stringify(result, null, 2);
   }
@@ -7888,6 +8160,8 @@ async function runAuthCommand(context) {
   throw new Error(`Unsupported auth subcommand: ${subcommand}.`);
 }
 async function runCommand(context) {
+  const extended = await runToolCommand(context.args, context.client, context.authState !== void 0, context.stravaLimitedAccess ?? false);
+  if (extended) return writeResult(context, "tool", extended.result);
   const top = shiftRequired(context.args, "command");
   if (top === "health") {
     return writeResult(context, "health", await context.client.health());
@@ -7957,52 +8231,28 @@ async function runCommand(context) {
       context: contextPayload
     }));
   }
-  if (top === "plan") {
-    const subcommand = shiftRequired(context.args, "plan subcommand");
-    if (subcommand === "current") {
-      const target = resolveAthleteTarget(context);
-      return target.useMyRoutes ? writeResult(context, "plan_current", await context.client.getMyCurrentPlan()) : writeResult(context, "plan_current", await context.client.getCurrentPlan({ athleteId: target.athleteId }));
+  if (top === "strava") {
+    const subcommand = shiftRequired(context.args, "strava subcommand");
+    requireSignedInAuth(context);
+    if (subcommand === "routes") {
+      const limit = parseIntegerOption(takeOption(context.args, "--limit"), "--limit");
+      return writeResult(context, "strava_routes", await context.client.listMyStravaRoutes({ ...limit === void 0 ? {} : { limit } }));
     }
-    if (subcommand === "schedule") {
-      const target = resolveAthleteTarget(context);
-      const workoutId = takeOption(context.args, "--workout-id");
-      const workoutVersion = parseIntegerOption(takeOption(context.args, "--version"), "--version");
-      const date = takeOption(context.args, "--date");
-      if (!workoutId) {
-        throw new Error("Missing required argument: --workout-id.");
-      }
-      if (workoutVersion === void 0) {
-        throw new Error("Missing required argument: --version.");
-      }
-      if (!date) {
-        throw new Error("Missing required argument: --date.");
-      }
-      return target.useMyRoutes ? writeResult(context, "plan_schedule", await context.client.scheduleMyWorkout({
-        workoutId,
-        workoutVersion,
-        date
-      })) : writeResult(context, "plan_schedule", await context.client.scheduleWorkout({
-        athleteId: target.athleteId,
-        workoutId,
-        workoutVersion,
-        date
-      }));
+    if (subcommand === "starred-segments") {
+      const limit = parseIntegerOption(takeOption(context.args, "--limit"), "--limit");
+      return writeResult(context, "strava_starred", await context.client.listMyStravaStarredSegments({ ...limit === void 0 ? {} : { limit } }));
     }
-    throw new Error(`Unsupported plan subcommand: ${subcommand}.`);
+    throw new Error(`Unsupported strava subcommand: ${subcommand}.`);
   }
-  if (top === "runtime-plan") {
-    const subcommand = shiftRequired(context.args, "runtime-plan subcommand");
-    if (subcommand !== "today") {
-      throw new Error(`Unsupported runtime-plan subcommand: ${subcommand}.`);
+  if (top === "course") {
+    const subcommand = shiftRequired(context.args, "course subcommand");
+    requireSignedInAuth(context);
+    if (subcommand === "import-strava-route" || subcommand === "import-strava-segment") {
+      const input = await readJsonInput(context.args);
+      if (input === void 0) throw new Error(`course ${subcommand} requires --input-json or --input-file.`);
+      return subcommand === "import-strava-route" ? writeResult(context, "course_import", await context.client.importMyStravaRoute(input)) : writeResult(context, "course_import", await context.client.importMyStravaSegment(input));
     }
-    const target = resolveAthleteTarget(context);
-    const date = takeOption(context.args, "--date");
-    return target.useMyRoutes ? writeResult(context, "runtime_plan_today", await context.client.getMyTodayRuntimePlan({
-      ...date === void 0 ? {} : { date }
-    })) : writeResult(context, "runtime_plan_today", await context.client.getTodayRuntimePlan({
-      athleteId: target.athleteId,
-      ...date === void 0 ? {} : { date }
-    }));
+    throw new Error(`Unsupported course subcommand: ${subcommand}.`);
   }
   if (top === "workout") {
     const subcommand = shiftRequired(context.args, "workout subcommand");
@@ -8093,7 +8343,22 @@ async function runCommand(context) {
         structuredInput
       ));
     }
+    if (subcommand === "list") {
+      const limit = parseIntegerOption(takeOption(context.args, "--limit"), "--limit");
+      const target = resolveAthleteTarget(context);
+      return target.useMyRoutes ? writeResult(context, "workout_list", await context.client.listMySavedWorkouts({ ...limit === void 0 ? {} : { limit } })) : writeResult(context, "workout_list", await context.client.listSavedWorkouts({ athleteId: target.athleteId, ...limit === void 0 ? {} : { limit } }));
+    }
     const workoutId = shiftRequired(context.args, "workoutId");
+    if (subcommand === "schedule" || subcommand === "unschedule") {
+      const date = takeOption(context.args, "--date");
+      if (subcommand === "schedule" && !date) throw new Error("Missing required argument: --date.");
+      if (subcommand === "unschedule" && date !== void 0) throw new Error("workout unschedule does not accept --date.");
+      const input = { workoutId, scheduledDate: subcommand === "schedule" ? date : null };
+      return context.authState ? writeResult(context, "workout_schedule", await context.client.scheduleMySavedWorkout(input)) : writeResult(context, "workout_schedule", await context.client.scheduleSavedWorkout(input));
+    }
+    if (subcommand === "retire") {
+      return context.authState ? writeResult(context, "workout_retire", await context.client.retireMySavedWorkout({ workoutId })) : writeResult(context, "workout_retire", await context.client.retireSavedWorkout({ workoutId }));
+    }
     if (subcommand === "get") {
       const workoutVersion = parseIntegerOption(takeOption(context.args, "--version"), "--version");
       return context.authState ? writeResult(context, "workout_get", await context.client.getMySavedWorkout({
@@ -8124,99 +8389,7 @@ async function runCommand(context) {
   }
   if (top === "session") {
     const subcommand = shiftRequired(context.args, "session subcommand");
-    if (subcommand === "load-workout") {
-      const athleteId = takeOption(context.args, "--athlete-id");
-      const workoutId = takeOption(context.args, "--workout-id");
-      const workoutVersion = parseIntegerOption(takeOption(context.args, "--version"), "--version");
-      if (!workoutId) {
-        throw new Error("Missing required argument: --workout-id.");
-      }
-      if (workoutVersion === void 0) {
-        throw new Error("Missing required argument: --version.");
-      }
-      if (!athleteId && context.authState) {
-        return writeResult(context, "session_load_workout", await context.client.sendMyWorkoutToActiveTrainerSession({
-          workoutId,
-          workoutVersion
-        }));
-      }
-      if (!athleteId) {
-        throw new Error("Missing required argument: --athlete-id.");
-      }
-      return writeResult(context, "session_load_workout", await context.client.sendToActiveTrainerSession({
-        athleteId,
-        workoutId,
-        workoutVersion
-      }));
-    }
     const sessionId = shiftRequired(context.args, "sessionId");
-    if (subcommand === "complete") {
-      const structuredInput = await readJsonInput(context.args);
-      if (structuredInput !== void 0) {
-        return context.authState ? writeResult(context, "session_complete", await context.client.ingestMyCompletedSession({
-          sessionId,
-          ...structuredInput
-        })) : writeResult(context, "session_complete", await context.client.ingestCompletedSession({
-          sessionId,
-          ...structuredInput
-        }));
-      }
-      const status = takeOption(context.args, "--status");
-      const completionKind = takeOption(context.args, "--completion-kind");
-      const startedAt = takeOption(context.args, "--started-at");
-      const endedAt = takeOption(context.args, "--ended-at");
-      const executionMode = takeOption(context.args, "--execution-mode");
-      const elapsedSec = parseIntegerOption(takeOption(context.args, "--elapsed-sec"), "--elapsed-sec");
-      const avgPower = parseNumberOption(takeOption(context.args, "--avg-power"), "--avg-power");
-      const avgHrBpm = parseNumberOption(takeOption(context.args, "--avg-hr-bpm"), "--avg-hr-bpm");
-      const maxHrBpm = parseNumberOption(takeOption(context.args, "--max-hr-bpm"), "--max-hr-bpm");
-      const compliancePct = parseNumberOption(takeOption(context.args, "--compliance-pct"), "--compliance-pct");
-      const completedDurationSec = parseNumberOption(takeOption(context.args, "--completed-duration-sec"), "--completed-duration-sec");
-      const completedTss = parseNumberOption(takeOption(context.args, "--completed-tss"), "--completed-tss");
-      const notes = takeOptions(context.args, "--note");
-      if (!status) {
-        throw new Error("session complete requires either --input-json/--input-file or at least --status.");
-      }
-      const completion = {
-        sessionId,
-        status,
-        ...completionKind === void 0 ? {} : { completionKind },
-        ...startedAt === void 0 ? {} : { startedAt },
-        ...endedAt === void 0 ? {} : { endedAt },
-        ...executionMode === void 0 ? {} : { executionMode },
-        ...elapsedSec === void 0 ? {} : { liveSummary: { elapsedSec } },
-        ...avgPower === void 0 && avgHrBpm === void 0 && maxHrBpm === void 0 && compliancePct === void 0 && completedDurationSec === void 0 && completedTss === void 0 ? {} : {
-          actualMetrics: {
-            ...avgPower === void 0 ? {} : { avgPower },
-            ...avgHrBpm === void 0 ? {} : { avgHrBpm },
-            ...maxHrBpm === void 0 ? {} : { maxHrBpm },
-            ...compliancePct === void 0 ? {} : { compliancePct },
-            ...completedDurationSec === void 0 ? {} : { completedDurationSec },
-            ...completedTss === void 0 ? {} : { completedTss }
-          }
-        },
-        ...notes.length === 0 ? {} : { notes }
-      };
-      return context.authState ? writeResult(context, "session_complete", await context.client.ingestMyCompletedSession(completion)) : writeResult(context, "session_complete", await context.client.ingestCompletedSession(completion));
-    }
-    if (subcommand === "adapt") {
-      const op = takeOption(context.args, "--op");
-      const reason = takeOption(context.args, "--reason");
-      const payload = await readJsonInput(context.args, "--payload-json", "--payload-file");
-      if (!op) {
-        throw new Error("Missing required argument: --op.");
-      }
-      if (!reason) {
-        throw new Error("Missing required argument: --reason.");
-      }
-      const adaptation = {
-        sessionId,
-        op,
-        reason,
-        ...payload === void 0 ? {} : { payload }
-      };
-      return context.authState ? writeResult(context, "session_adapt", await context.client.adaptMyActiveSession(adaptation)) : writeResult(context, "session_adapt", await context.client.adaptActiveSession(adaptation));
-    }
     if (subcommand === "summary") {
       return context.authState ? writeResult(context, "session_summary", await context.client.summarizeMySession({ sessionId })) : writeResult(context, "session_summary", await context.client.summarizeSession({ sessionId }));
     }
@@ -8284,7 +8457,8 @@ async function runPlannerCli(options) {
       stdout,
       stderr,
       client,
-      authState: await authController.loadState()
+      authState: await authController.loadState(),
+      stravaLimitedAccess: ["1", "true", "yes", "on"].includes((env.WATTSON_STRAVA_LIMITED_ACCESS ?? env.PLANNER_MCP_STRAVA_LIMITED_ACCESS ?? "").trim().toLowerCase())
     });
   } catch (error) {
     writeError(stderr, error);